Use a single shader programm for rendering (#18)

Author: Bercon

python/cli/visualization/visualizer_renderers/mesh.py

@@ -26,23 +26,21 @@ def __init__(self, program):
 
 class MeshRenderer:
     meshProgram = None
-    mesh = None
-    updated = False
-    vbo_position = None
-    vbo_color = None
-    ebo = None
 
     def __init__(self, mesh=None, opacity=1.0):
         self.mesh = mesh
         self.updated = mesh is not None
         self.opacity = opacity
+        self.vbo_position = None
+        self.vbo_color = None
+        self.ebo = None
 
     def render(self, modelMatrix, viewMatrix, projectionMatrix):
-        if self.meshProgram is None:
+        if MeshRenderer.meshProgram is None:
             assetDir = pathlib.Path(__file__).resolve().parent
             vert = (assetDir / "mesh.vert").read_text()
             frag = (assetDir / "mesh.frag").read_text()
-            self.meshProgram = MeshProgram(createProgram(vert, frag))
+            MeshRenderer.meshProgram = MeshProgram(createProgram(vert, frag))
 
         if self.mesh is None: return
         modelView = viewMatrix @ modelMatrix
@@ -53,10 +51,10 @@ def render(self, modelMatrix, viewMatrix, projectionMatrix):
         if self.opacity >= 1.0: glDepthMask(GL_TRUE)
         else: glDepthMask(GL_FALSE)
 
-        glUseProgram(self.meshProgram.program)
-        glUniformMatrix4fv(self.meshProgram.uniformModelView, 1, GL_FALSE, modelView.transpose())
-        glUniformMatrix4fv(self.meshProgram.uniformProjection, 1, GL_FALSE, projectionMatrix.transpose())
-        glUniform1f(self.meshProgram.uniformOpacity, self.opacity)
+        glUseProgram(MeshRenderer.meshProgram.program)
+        glUniformMatrix4fv(MeshRenderer.meshProgram.uniformModelView, 1, GL_FALSE, modelView.transpose())
+        glUniformMatrix4fv(MeshRenderer.meshProgram.uniformProjection, 1, GL_FALSE, projectionMatrix.transpose())
+        glUniform1f(MeshRenderer.meshProgram.uniformOpacity, self.opacity)
 
         if self.updated:
             self.updated = False

python/cli/visualization/visualizer_renderers/point_cloud.py

@@ -43,10 +43,13 @@ def __init__(self, program):
         self.uniformColorMode = glGetUniformLocation(self.program, "u_ColorMode")
         self.uniformHasColor = glGetUniformLocation(self.program, "u_HasColor")
         self.uniformHasNormal = glGetUniformLocation(self.program, "u_HasNormal")
+        self.uniformMaxZ = glGetUniformLocation(self.program, "u_maxZ")
+        self.uniformColorMapScale = glGetUniformLocation(self.program, "u_colorMapScale")
 
 class PointCloudRenderer:
+    pcProgram = None
+
     def __init__(self, pointCloud=None, pointSize=1.0, opacity=1.0, maxZ=None, colorMapScale=1.0):
-        self.pcProgram = None
         self.pointCloud = pointCloud
         self.vboPosition = None
         self.vboColor = None
@@ -60,18 +63,11 @@ def __init__(self, pointCloud=None, pointSize=1.0, opacity=1.0, maxZ=None, color
         self.colorMapScale = 0.05 * colorMapScale
 
     def render(self, modelMatrix, viewMatrix, projectionMatrix):
-        if self.pcProgram is None:
+        if PointCloudRenderer.pcProgram is None:
             assetDir = pathlib.Path(__file__).resolve().parent
             pcVert = (assetDir / "point_cloud.vert").read_text()
-            # Poor man's GLSL templates
-            replaceMap = {
-                '{MAX_Z}': str(self.maxZ),
-                '{COLOR_MAP_SCALE}': str(self.colorMapScale)
-            }
-            for k, v in replaceMap.items():
-                pcVert = pcVert.replace(k, v)
             pcFrag = (assetDir / "point_cloud.frag").read_text()
-            self.pcProgram = PointCloudProgram(createProgram(pcVert, pcFrag))
+            PointCloudRenderer.pcProgram = PointCloudProgram(createProgram(pcVert, pcFrag))
 
         if self.pointCloud is None: return
 
@@ -83,17 +79,19 @@ def render(self, modelMatrix, viewMatrix, projectionMatrix):
         if self.opacity >= 1.0: glDepthMask(GL_TRUE)
         else: glDepthMask(GL_FALSE)
 
-        glUseProgram(self.pcProgram.program)
-        glUniformMatrix4fv(self.pcProgram.uniformModel, 1, GL_FALSE, modelMatrix.transpose())
-        glUniformMatrix4fv(self.pcProgram.uniformView, 1, GL_FALSE, viewMatrix.transpose())
-        glUniformMatrix4fv(self.pcProgram.uniformProjection, 1, GL_FALSE, projectionMatrix.transpose())
-        glUniform3f(self.pcProgram.uniformCameraPositionWorld, self.cameraPositionWorld[0], self.cameraPositionWorld[1], self.cameraPositionWorld[2])
-
-        glUniform1f(self.pcProgram.uniformPointSize, self.pointSize)
-        glUniform1f(self.pcProgram.uniformOpacity, self.opacity)
-        glUniform1i(self.pcProgram.uniformColorMode, self.colorMode)
-        glUniform1i(self.pcProgram.uniformHasColor, 0 if self.pointCloud.colors is None else 1)
-        glUniform1i(self.pcProgram.uniformHasNormal, 0 if self.pointCloud.normals is None else 1)
+        glUseProgram(PointCloudRenderer.pcProgram.program)
+        glUniformMatrix4fv(PointCloudRenderer.pcProgram.uniformModel, 1, GL_FALSE, modelMatrix.transpose())
+        glUniformMatrix4fv(PointCloudRenderer.pcProgram.uniformView, 1, GL_FALSE, viewMatrix.transpose())
+        glUniformMatrix4fv(PointCloudRenderer.pcProgram.uniformProjection, 1, GL_FALSE, projectionMatrix.transpose())
+        glUniform3f(PointCloudRenderer.pcProgram.uniformCameraPositionWorld, self.cameraPositionWorld[0], self.cameraPositionWorld[1], self.cameraPositionWorld[2])
+
+        glUniform1f(PointCloudRenderer.pcProgram.uniformPointSize, self.pointSize)
+        glUniform1f(PointCloudRenderer.pcProgram.uniformOpacity, self.opacity)
+        glUniform1i(PointCloudRenderer.pcProgram.uniformColorMode, self.colorMode)
+        glUniform1i(PointCloudRenderer.pcProgram.uniformHasColor, 0 if self.pointCloud.colors is None else 1)
+        glUniform1i(PointCloudRenderer.pcProgram.uniformHasNormal, 0 if self.pointCloud.normals is None else 1)
+        glUniform1f(PointCloudRenderer.pcProgram.uniformMaxZ, self.maxZ)
+        glUniform1f(PointCloudRenderer.pcProgram.uniformColorMapScale, self.colorMapScale)
 
         if self.updated:
             self.updated = False

python/cli/visualization/visualizer_renderers/point_cloud.vert

@@ -10,6 +10,8 @@ uniform mat4 u_Projection;
 uniform vec3 u_CameraPositionWorld;
 uniform float u_PointSize;
 uniform float u_Opacity;
+uniform float u_maxZ;
+uniform float u_colorMapScale;
 // 0 = original colors
 // 1 = x
 // 2 = y
@@ -22,9 +24,6 @@ uniform int u_HasNormal;  // 0 == false, otherwise true
 
 out vec4 frag_Color;
 
-const float MAX_Z = float({MAX_Z});
-const float COLOR_MAP_SCALE = float({COLOR_MAP_SCALE});
-
 vec3 colorMapJET(float value) {
     float r = clamp(1.5 - abs(3.0 - 4.0 * value), 0.0, 1.0);
     float g = clamp(1.5 - abs(2.0 - 4.0 * value), 0.0, 1.0);
@@ -45,25 +44,25 @@ void main() {
     vec3 color = vec3(0.0, 0.17, 0.21); // default color
     float opacity = u_Opacity;
 
-    if (MAX_Z != float(0.0) && v_PositionWorld.z > MAX_Z) {
+    if (u_maxZ != float(0.0) && v_PositionWorld.z > u_maxZ) {
         // discard
         gl_Position.w = 0;
     } else {
         switch (u_ColorMode) {
             case 1:
-                color = colorMapJET(0.5 - v_PositionWorld.x * COLOR_MAP_SCALE);
+                color = colorMapJET(0.5 - v_PositionWorld.x * u_colorMapScale);
                 break;
 
             case 2:
-                color = colorMapJET(0.5 - v_PositionWorld.y * COLOR_MAP_SCALE);
+                color = colorMapJET(0.5 - v_PositionWorld.y * u_colorMapScale);
                 break;
 
             case 3:
-                color = colorMapJET(0.5 + v_PositionWorld.z * COLOR_MAP_SCALE * 2.0);
+                color = colorMapJET(0.5 + v_PositionWorld.z * u_colorMapScale * 2.0);
                 break;
 
             case 4:
-                float depth = length(v_PositionWorld.xyz - u_CameraPositionWorld.xyz) * COLOR_MAP_SCALE * 5.0;
+                float depth = length(v_PositionWorld.xyz - u_CameraPositionWorld.xyz) * u_colorMapScale * 5.0;
                 color = colorMapJET(exp(-depth*0.5));
                 break;