Merge pull request #215 from compas-dev/feature/linewidth

Line width is back!

Author: Licini

CHANGELOG.md

@@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+* Made `linewidth` working again through `GeometryShader`.
+
 ### Removed
 
 

scripts/example.py

@@ -3,6 +3,7 @@
 from compas.datastructures import Mesh
 from compas.geometry import Box
 from compas.geometry import Frame
+from random import random
 from compas_viewer.viewer import Viewer
 
 viewer = Viewer(show_grid=True)
@@ -17,9 +18,13 @@
     for j in range(M):
         viewer.scene.add(
             Box(0.5, 0.5, 0.5, Frame([i, j, 0], [1, 0, 0], [0, 1, 0])),
-            linecolor=Color.white(),
+            linecolor=Color.from_i(random()),
             facecolor=Color(i / N, j / M, 0.0),
             name=f"Box_{i}_{j}",
+            linewidth=3 * random(),
+            show_points=True,
+            pointcolor=Color.from_i(random()),
+            pointsize=10
         )
 
 viewer.show()

src/compas_viewer/renderer/renderer.py

@@ -62,6 +62,7 @@ def __init__(self, viewer: "Viewer"):
         self.grid = None
 
         self.shader_model: Shader = None
+        self.shader_lines: Shader = None
         self._shader_tag: Shader = None
         self.shader_arrow: Shader = None
         self.shader_instance: Shader = None
@@ -108,6 +109,9 @@ def rendermode(self, rendermode):
             self.shader_model.bind()
             self.shader_model.uniform1f("opacity", self._opacity)
             self.shader_model.release()
+            self.shader_lines.bind()
+            self.shader_lines.uniform1f("opacity", self._opacity)
+            self.shader_lines.release()
             self.update()
 
     @property
@@ -197,7 +201,6 @@ def initializeGL(self):
         """
         GL.glClearColor(*self.viewer.config.renderer.backgroundcolor.rgba)
         GL.glPolygonOffset(1.0, 1.0)
-        GL.glEnable(GL.GL_POLYGON_OFFSET_FILL)
         GL.glEnable(GL.GL_CULL_FACE)
         GL.glCullFace(GL.GL_BACK)
         GL.glEnable(GL.GL_DEPTH_TEST)
@@ -432,6 +435,16 @@ def init(self):
         self.shader_model.uniformBuffer("settingsBuffer", self.buffer_manager.settings_texture, unit=1)
         self.shader_model.release()
 
+        self.shader_lines = Shader(name="modellines")
+        self.shader_lines.bind()
+        self.shader_lines.uniform4x4("projection", projection)
+        self.shader_lines.uniform4x4("viewworld", viewworld)
+        self.shader_lines.uniform1f("opacity", self.opacity)
+        self.shader_lines.uniform3f("selection_color", self.viewer.config.renderer.selectioncolor.rgb)
+        self.shader_lines.uniformBuffer("transformBuffer", self.buffer_manager.transform_texture, unit=0)
+        self.shader_lines.uniformBuffer("settingsBuffer", self.buffer_manager.settings_texture, unit=1)
+        self.shader_lines.release()
+
     def update_projection(self, w=None, h=None):
         """
         Update the projection matrix.
@@ -451,6 +464,10 @@ def update_projection(self, w=None, h=None):
         self.shader_model.uniform4x4("projection", projection)
         self.shader_model.release()
 
+        self.shader_lines.bind()
+        self.shader_lines.uniform4x4("projection", projection)
+        self.shader_lines.release()
+
         self.shader_tag.bind()
         self.shader_tag.uniform4x4("projection", projection)
         self.shader_tag.release()
@@ -508,21 +525,34 @@ def paint(self, is_instance: bool = False):
         viewworld = self.camera.viewworld()
         self.update_projection()
 
-        # rebind the model shader
-        self.shader_model.bind()
-        self.shader_model.uniform1f("opacity", self.opacity)
-        self.shader_model.uniformBuffer("transformBuffer", self.buffer_manager.transform_texture, unit=0)
-        self.shader_model.uniformBuffer("settingsBuffer", self.buffer_manager.settings_texture, unit=1)
-
-        self.shader_model.uniform4x4("viewworld", viewworld)
-        self.shader_model.uniform1i("is_instance", is_instance)
-
+        # Update object settings (visibility, selection, etc.)
+        self.buffer_manager.update_settings()
+
+        # Update uniforms for both shaders
+        for shader in [self.shader_model, self.shader_lines]:
+            shader.bind()
+            shader.uniform1f("opacity", self.opacity)
+            shader.uniformBuffer("transformBuffer", self.buffer_manager.transform_texture, unit=0)
+            shader.uniformBuffer("settingsBuffer", self.buffer_manager.settings_texture, unit=1)
+            shader.uniform4x4("viewworld", viewworld)
+            shader.uniform1i("is_instance", is_instance)
+            shader.release()
+
+        # Update viewport uniform for line shader
+        self.shader_lines.bind()
+        self.shader_lines.uniform2f("viewport", (self.width(), self.height()))
+        self.shader_lines.release()
+
+        # Draw the grid
         if self.viewer.config.renderer.show_grid:
+            self.shader_model.bind()
             self.grid.draw(self.shader_model)
+            self.shader_model.release()
 
         # Draw all the objects in the buffer manager
         self.buffer_manager.draw(
             self.shader_model,
+            self.shader_lines,
             self.rendermode,
             is_instance=is_instance,
         )
@@ -531,7 +561,6 @@ def paint(self, is_instance: bool = False):
         tag_objs = [obj for obj in self.viewer.scene.objects if isinstance(obj, TagObject)]
         if tag_objs:
             # release the model shader and bind the tag shader
-            self.shader_model.release()
             self.shader_tag.bind()
             self.shader_tag.uniform4x4("viewworld", viewworld)
             for obj in tag_objs:
@@ -540,7 +569,7 @@ def paint(self, is_instance: bool = False):
 
         # draw 2D box for multi-selection
         if self.viewer.mouse.is_tracing_a_window:
-            # Ensure the shader is bound before drawing
+            # Ensure the model shader is bound before drawing
             self.shader_model.bind()
 
             # Draw the selection box
@@ -554,6 +583,7 @@ def paint(self, is_instance: bool = False):
                 self.width(),
                 self.height(),
             )
+            self.shader_model.release()
 
         # Unbind once we're done
         GL.glBindVertexArray(0)

src/compas_viewer/renderer/shaders/modellines.frag

@@ -0,0 +1,68 @@
+#version 330 core
+
+// Inputs
+in vec4 g_vertex_color;
+in vec3 g_ec_pos;
+in float g_is_selected;
+in float g_show;
+in float g_show_points;
+in float g_show_lines;
+in float g_show_faces;
+in vec4 g_instance_color;
+in float g_object_opacity;
+
+// Uniforms
+uniform float opacity;
+uniform bool is_lighted;
+uniform vec3 selection_color;
+uniform int element_type;
+uniform bool is_instance;
+uniform bool is_grid;
+
+out vec4 fragColor;
+
+void main() {
+    // Early visibility checks
+    if (g_show == 0.0 || 
+        (element_type == 0 && g_show_points == 0.0) ||
+        (element_type == 1 && g_show_lines == 0.0) ||
+        (element_type == 2 && g_show_faces == 0.0) ||
+        (is_instance && is_grid)) {
+        discard;
+    }
+
+    // Handle instanced objects
+    if (is_instance) {
+        fragColor = g_instance_color;
+        return;
+    }
+
+    // Calculate color and alpha
+    float alpha = opacity * g_object_opacity * g_vertex_color.a;
+    vec3 color = g_vertex_color.rgb;
+
+    // Handle selection highlighting
+    if (g_is_selected > 0.5) {
+        color = selection_color * (element_type == 0 ? 0.9 : 
+                                 element_type == 1 ? 0.8 : 
+                                 1.0);
+        alpha = max(alpha, 0.5);
+    }
+
+    // Draw circular points
+    if (element_type == 0) {
+        vec2 center = gl_PointCoord - vec2(0.5);
+        if (length(center) > 0.5) {
+            discard;
+        }
+    }
+
+    // Apply lighting if needed
+    if (is_lighted && !is_grid) {
+        vec3 ec_normal = normalize(cross(dFdx(g_ec_pos), dFdy(g_ec_pos)));
+        vec3 L = normalize(-g_ec_pos);
+        fragColor = vec4(color * dot(ec_normal, L), alpha);
+    } else {
+        fragColor = vec4(color, alpha);
+    }
+} 

src/compas_viewer/renderer/shaders/modellines.geom

@@ -0,0 +1,76 @@
+#version 330 core
+
+layout (lines) in;
+layout (triangle_strip, max_vertices = 4) out;
+
+// from vertex shader
+in vec4 vertex_color[];
+in vec3 ec_pos[];
+in float is_selected[];
+in float show[];
+in float show_points[];
+in float show_lines[];
+in float show_faces[];
+in vec4 instance_color[];
+in float object_opacity[];
+in float linewidth[];
+
+// to fragment shader
+out vec4 g_vertex_color;
+out vec3 g_ec_pos;
+out float g_is_selected;
+out float g_show;
+out float g_show_points;
+out float g_show_lines;
+out float g_show_faces;
+out vec4 g_instance_color;
+out float g_object_opacity;
+
+uniform vec2 viewport; // The (width, height) of the viewport in pixels
+
+void main() {
+    vec2 p1 = gl_in[0].gl_Position.xy / gl_in[0].gl_Position.w;
+    vec2 p2 = gl_in[1].gl_Position.xy / gl_in[1].gl_Position.w;
+
+    vec2 dir = normalize(p2 - p1);
+    vec2 normal = vec2(-dir.y, dir.x);
+
+    float width = linewidth[0];
+    vec2 offset = normal * width / viewport;
+
+    // Vertex 1
+    gl_Position = vec4((p1 - offset) * gl_in[0].gl_Position.w, gl_in[0].gl_Position.zw);
+    g_vertex_color = vertex_color[0];
+    g_ec_pos = ec_pos[0];
+    g_is_selected = is_selected[0];
+    g_show = show[0];
+    g_show_points = show_points[0];
+    g_show_lines = show_lines[0];
+    g_show_faces = show_faces[0];
+    g_instance_color = instance_color[0];
+    g_object_opacity = object_opacity[0];
+    EmitVertex();
+
+    // Vertex 2
+    gl_Position = vec4((p1 + offset) * gl_in[0].gl_Position.w, gl_in[0].gl_Position.zw);
+    EmitVertex();
+
+    // Vertex 3
+    gl_Position = vec4((p2 - offset) * gl_in[1].gl_Position.w, gl_in[1].gl_Position.zw);
+    g_vertex_color = vertex_color[1];
+    g_ec_pos = ec_pos[1];
+    g_is_selected = is_selected[1];
+    g_show = show[1];
+    g_show_points = show_points[1];
+    g_show_lines = show_lines[1];
+    g_show_faces = show_faces[1];
+    g_instance_color = instance_color[1];
+    g_object_opacity = object_opacity[1];
+    EmitVertex();
+
+    // Vertex 4
+    gl_Position = vec4((p2 + offset) * gl_in[1].gl_Position.w, gl_in[1].gl_Position.zw);
+    EmitVertex();
+
+    EndPrimitive();
+}