From 4a233398070bef748264bb3fd346ef559d66e9f7 Mon Sep 17 00:00:00 2001 From: austin Date: Thu, 22 May 2025 20:55:12 -0400 Subject: [PATCH] standard uniform manager impl --- assets/Shaders/lib/standarduniform.fs | 44 +++++ docs/src/progress/renderertodo.md | 1 + .../renderer/RenderingEngine.java | 21 +++ .../electrosphere/renderer/model/Mesh.java | 2 + .../shader/StandardUniformManager.java | 164 ++++++++++++++++++ 5 files changed, 232 insertions(+) create mode 100644 assets/Shaders/lib/standarduniform.fs create mode 100644 src/main/java/electrosphere/renderer/shader/StandardUniformManager.java diff --git a/assets/Shaders/lib/standarduniform.fs b/assets/Shaders/lib/standarduniform.fs new file mode 100644 index 00000000..4b0de5c2 --- /dev/null +++ b/assets/Shaders/lib/standarduniform.fs @@ -0,0 +1,44 @@ + +/** + * Bind point for the standard uniform SSBO + */ +#define STANDARD_UNIFORM_SSBO_BIND_POINT 4 + +/** + * The standard uniforms + */ +struct StandardUniforms { + /** + * The view matrix + */ + mat4 view; + /** + * The projection matrix + */ + mat4 projection; + /** + * The light-space matrix + */ + mat4 lightSpaceMatrix; + /** + * The view position + */ + vec4 viewPos; + /** + * The current frame count + */ + uint frame; + /** + * The current engine time + */ + float time; +}; + +/** + * Cutoff for fragment alpha + */ +#define FRAGMENT_ALPHA_CUTOFF 0.001 + +layout(std430, binding = STANDARD_UNIFORM_SSBO_BIND_POINT) restrict buffer standardUniformSSBO { + StandardUniforms standardUniforms; +}; diff --git a/docs/src/progress/renderertodo.md b/docs/src/progress/renderertodo.md index 61911969..b75a15f5 100644 --- a/docs/src/progress/renderertodo.md +++ b/docs/src/progress/renderertodo.md @@ -1942,6 +1942,7 @@ Main content pipeline tracking Error checking on mesh rendering (making sure not trying to draw 0-element meshes) Fix generating rendering geometry for blocks/terrain with 0 elements GriddedDataCellManager filtering optimization +StandardUniformManager implementation diff --git a/src/main/java/electrosphere/renderer/RenderingEngine.java b/src/main/java/electrosphere/renderer/RenderingEngine.java index 3964c2bc..25ec27b1 100644 --- a/src/main/java/electrosphere/renderer/RenderingEngine.java +++ b/src/main/java/electrosphere/renderer/RenderingEngine.java @@ -53,6 +53,7 @@ import electrosphere.renderer.pipelines.ShadowMapPipeline; import electrosphere.renderer.pipelines.UIPipeline; import electrosphere.renderer.pipelines.VolumeBufferPipeline; import electrosphere.renderer.pipelines.debug.DebugContentPipeline; +import electrosphere.renderer.shader.StandardUniformManager; import electrosphere.renderer.shader.VisualShader; import electrosphere.renderer.target.DrawTargetEvaluator; import electrosphere.renderer.texture.Texture; @@ -173,6 +174,11 @@ public class RenderingEngine { * The light manager for the rendering engine */ LightManager lightManager; + + /** + * The standard uniform manager + */ + private StandardUniformManager standardUniformManager; /** * The output framebuffer @@ -473,6 +479,10 @@ public class RenderingEngine { //instantiate light manager lightManager = LightManager.create(); + + // + //instantiate standard uniform manager + standardUniformManager = StandardUniformManager.create(); // //Fog @@ -545,6 +555,9 @@ public class RenderingEngine { this.updateFrustumBox(); } + //update standard uniforms + this.standardUniformManager.update(); + //determine draw targets if(this.RENDER_FLAG_RENDER_SCREEN_FRAMEBUFFER_CONTENT && shouldRunPipelines()){ DrawTargetEvaluator.evaluate(); @@ -805,6 +818,14 @@ public class RenderingEngine { return this.windowPtr; } + /** + * Gets the standard uniform manager + * @return The standard uniform manager + */ + public StandardUniformManager getStandardUniformManager(){ + return this.standardUniformManager; + } + /** * Tries to recapture the screen */ diff --git a/src/main/java/electrosphere/renderer/model/Mesh.java b/src/main/java/electrosphere/renderer/model/Mesh.java index 6d4f9339..c887d8ea 100644 --- a/src/main/java/electrosphere/renderer/model/Mesh.java +++ b/src/main/java/electrosphere/renderer/model/Mesh.java @@ -9,6 +9,7 @@ import electrosphere.renderer.RenderingEngine; import electrosphere.renderer.actor.ActorTextureMask; import electrosphere.renderer.actor.instance.InstanceData; import electrosphere.renderer.light.LightManager; +import electrosphere.renderer.shader.StandardUniformManager; import electrosphere.renderer.shader.VisualShader; import electrosphere.renderer.texture.Texture; import java.nio.FloatBuffer; @@ -558,6 +559,7 @@ public class Mesh { openGLState.getActiveShader().setUniform(openGLState, "lightSpaceMatrix", Globals.renderingEngine.getLightDepthMatrix()); openGLState.getActiveShader().setUniform(openGLState, "frame", (int)Globals.engineState.timekeeper.getNumberOfRenderFramesElapsed()); openGLState.getActiveShader().setUniform(openGLState, "time", (float)Globals.engineState.timekeeper.getCurrentRendererTime()); + openGLState.glBindBufferBase(StandardUniformManager.STANDARD_UNIFORM_BUFFER_BIND_POINT, Globals.renderingEngine.getStandardUniformManager().getStandardUnifomSSBO()); } Globals.renderingEngine.checkError(); } diff --git a/src/main/java/electrosphere/renderer/shader/StandardUniformManager.java b/src/main/java/electrosphere/renderer/shader/StandardUniformManager.java new file mode 100644 index 00000000..a3669646 --- /dev/null +++ b/src/main/java/electrosphere/renderer/shader/StandardUniformManager.java @@ -0,0 +1,164 @@ +package electrosphere.renderer.shader; + +import java.nio.ByteBuffer; + +import org.joml.Matrix4d; +import org.joml.Vector3d; + +import electrosphere.client.entity.camera.CameraEntityUtils; +import electrosphere.engine.Globals; +import electrosphere.renderer.buffer.ShaderStorageBuffer; +import electrosphere.renderer.buffer.BufferEnums.BufferAccess; +import electrosphere.renderer.buffer.BufferEnums.BufferUsage; + +/** + * Manages the standard uniforms + */ +public class StandardUniformManager { + + /** + * Bind point of the standard uniform buffer + */ + public static final int STANDARD_UNIFORM_BUFFER_BIND_POINT = 4; + + /** + * Size of the standard uniform ssbo + */ + public static final int STANDARD_UNIFORM_SSBO_SIZE = 216; + + /** + * The standard uniform ssbo + Standard uniform struct: + { + mat4 view; //64 bytes + mat4 projection; //64 bytes + mat4 lightSpaceMatrix; //64 bytes + vec4 viewPos; //16 bytes + unsigned int frame; //4 bytes + float time; //4 bytes + } + Totals to 216 bytes + */ + private ShaderStorageBuffer standardUniformSSBO; + + /** + * Private constructor + */ + private StandardUniformManager(){} + + /** + * Creates the standard uniform manager + * @return The standard uniform manager + */ + public static StandardUniformManager create(){ + StandardUniformManager rVal = new StandardUniformManager(); + rVal.standardUniformSSBO = new ShaderStorageBuffer(STANDARD_UNIFORM_SSBO_SIZE, BufferUsage.DYNAMIC, BufferAccess.DRAW); + return rVal; + } + + /** + * Updates the standard uniform manager + */ + public void update(){ + ByteBuffer buff = standardUniformSSBO.getBuffer(); + + //put the view matrix + Matrix4d viewMat = Globals.renderingEngine.getViewMatrix(); + buff.putFloat((float)viewMat.m00()); + buff.putFloat((float)viewMat.m01()); + buff.putFloat((float)viewMat.m02()); + buff.putFloat((float)viewMat.m03()); + + buff.putFloat((float)viewMat.m10()); + buff.putFloat((float)viewMat.m11()); + buff.putFloat((float)viewMat.m12()); + buff.putFloat((float)viewMat.m13()); + + buff.putFloat((float)viewMat.m20()); + buff.putFloat((float)viewMat.m21()); + buff.putFloat((float)viewMat.m22()); + buff.putFloat((float)viewMat.m23()); + + buff.putFloat((float)viewMat.m30()); + buff.putFloat((float)viewMat.m31()); + buff.putFloat((float)viewMat.m32()); + buff.putFloat((float)viewMat.m33()); + + //put the projection matrix + Matrix4d projectionMat = Globals.renderingEngine.getProjectionMatrix(); + buff.putFloat((float)projectionMat.m00()); + buff.putFloat((float)projectionMat.m01()); + buff.putFloat((float)projectionMat.m02()); + buff.putFloat((float)projectionMat.m03()); + + buff.putFloat((float)projectionMat.m10()); + buff.putFloat((float)projectionMat.m11()); + buff.putFloat((float)projectionMat.m12()); + buff.putFloat((float)projectionMat.m13()); + + buff.putFloat((float)projectionMat.m20()); + buff.putFloat((float)projectionMat.m21()); + buff.putFloat((float)projectionMat.m22()); + buff.putFloat((float)projectionMat.m23()); + + buff.putFloat((float)projectionMat.m30()); + buff.putFloat((float)projectionMat.m31()); + buff.putFloat((float)projectionMat.m32()); + buff.putFloat((float)projectionMat.m33()); + + //put the light space matrix + Matrix4d lightSpaceMat = Globals.renderingEngine.getLightDepthMatrix(); + buff.putFloat((float)lightSpaceMat.m00()); + buff.putFloat((float)lightSpaceMat.m01()); + buff.putFloat((float)lightSpaceMat.m02()); + buff.putFloat((float)lightSpaceMat.m03()); + + buff.putFloat((float)lightSpaceMat.m10()); + buff.putFloat((float)lightSpaceMat.m11()); + buff.putFloat((float)lightSpaceMat.m12()); + buff.putFloat((float)lightSpaceMat.m13()); + + buff.putFloat((float)lightSpaceMat.m20()); + buff.putFloat((float)lightSpaceMat.m21()); + buff.putFloat((float)lightSpaceMat.m22()); + buff.putFloat((float)lightSpaceMat.m23()); + + buff.putFloat((float)lightSpaceMat.m30()); + buff.putFloat((float)lightSpaceMat.m31()); + buff.putFloat((float)lightSpaceMat.m32()); + buff.putFloat((float)lightSpaceMat.m33()); + + //put the view pos + Vector3d viewPos = CameraEntityUtils.getCameraEye(Globals.clientState.playerCamera); + if(viewPos != null){ + buff.putFloat((float)viewPos.x); + buff.putFloat((float)viewPos.y); + buff.putFloat((float)viewPos.z); + buff.putFloat((float)1); + } else { + buff.putFloat((float)1); + buff.putFloat((float)0); + buff.putFloat((float)0); + buff.putFloat((float)1); + } + + //put the frame count + buff.putInt((int)Globals.engineState.timekeeper.getNumberOfRenderFramesElapsed()); + + //put the engine time + buff.putFloat((float)Globals.engineState.timekeeper.getCurrentRendererTime()); + + + buff.flip(); + standardUniformSSBO.upload(Globals.renderingEngine.getOpenGLState()); + } + + /** + * Gets the standard uniform ssbo + * @return The standard uniform ssbo + */ + public ShaderStorageBuffer getStandardUnifomSSBO(){ + return this.standardUniformSSBO; + } + +}