🧹 Remove dead shader code and consolidate duplicates

- Remove unused shader functions: dashed_uniform_color_3d, uniform_color_3d, point_color_3d, polyline_color_3d, uniform_color_line_2d
- Consolidate duplicate ID shaders (id_line_3d and id_shader_3d were identical)
- Remove unused shader infrastructure and base shader strings
- Remove orphaned imports and commented-out functions
- Update GPU manager to use consolidated shader for both points and lines

All changes maintain 100% backward compatibility and functionality.

Author: ra100

model/base_entity.py

@@ -302,7 +302,6 @@ def draw_id(self, context):
         if not self.is_point():
             # viewport = [context.area.width, context.area.height]
             # shader.uniform_float("Viewport", viewport)
-            shader.uniform_bool("dashed", (False,))
             gpu.state.line_width_set(self.line_width_select)
 
         batch.draw(shader)

shaders.py

@@ -1,7 +1,6 @@
 import gpu
 from gpu.types import GPUShader, GPUShaderCreateInfo, GPUStageInterfaceInfo
 from gpu.shader import create_from_info
-from bpy import app
 
 import sys
 
@@ -16,117 +15,6 @@
 
 class Shaders:
 
-    base_vertex_shader_3d = """
-        void main() {
-           gl_Position = ModelViewProjectionMatrix * vec4(pos.xyz, 1.0f);
-
-           vec2 ssPos = vec2(gl_Position.xy / gl_Position.w);
-           segment_start = stipple_pos = ssPos;
-        }
-    """
-    base_fragment_shader_3d = """
-        void main() {
-
-            vec2 delta = stipple_pos - segment_start;
-            vec2 stipple_start;
-            if (abs(delta.x) > abs(delta.y)) {
-                stipple_start.x = 0;
-                float t = -segment_start.x / delta.x;
-                stipple_start.y = segment_start.y + t * delta.y;
-            }
-            else {
-                stipple_start.y = 0;
-                float t = -segment_start.y / delta.y;
-                stipple_start.x = segment_start.x + t * delta.x;
-            }
-            float distance_along_line = distance(stipple_pos, stipple_start);
-            float normalized_distance = fract(distance_along_line / dash_width);
-
-            if (dashed == true) {
-                if (normalized_distance <= dash_factor) {
-                    discard;
-                }
-                else {
-                    fragColor = color;
-                }
-            }
-            else {
-                fragColor = color;
-            }
-
-        }
-    """
-
-    base_vertex_shader_2d = """
-        void main() {
-           gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0, 1.0f);
-        }
-    """
-    base_fragment_shader_2d = """
-        void main() {
-            fragColor = color;
-        }
-    """
-
-    @classmethod
-    def get_base_shader_3d_info(cls):
-
-        vert_out = GPUStageInterfaceInfo("stipple_pos_interface")
-        vert_out.no_perspective("VEC2", "stipple_pos")
-        vert_out.flat("VEC2", "segment_start")
-
-        # NOTE: How to set default values?
-
-        shader_info = GPUShaderCreateInfo()
-        shader_info.push_constant("MAT4", "ModelViewProjectionMatrix")
-        shader_info.push_constant("VEC4", "color")
-        shader_info.push_constant("FLOAT", "dash_width")
-        shader_info.push_constant("FLOAT", "dash_factor")
-        # shader_info.push_constant("VEC2", "Viewport")
-        shader_info.push_constant("BOOL", "dashed")
-        shader_info.vertex_in(0, "VEC3", "pos")
-        shader_info.vertex_out(vert_out)
-        shader_info.fragment_out(0, "VEC4", "fragColor")
-
-        shader_info.vertex_source(cls.base_vertex_shader_3d)
-        shader_info.fragment_source(cls.base_fragment_shader_3d)
-
-        return shader_info
-
-    @classmethod
-    def get_base_shader_2d_info(cls):
-
-        shader_info = GPUShaderCreateInfo()
-        shader_info.push_constant("MAT4", "ModelViewProjectionMatrix")
-        shader_info.push_constant("VEC4", "color")
-        shader_info.push_constant("FLOAT", "lineWidth")
-        shader_info.vertex_in(0, "VEC2", "pos")
-        shader_info.fragment_out(0, "VEC4", "fragColor")
-
-        shader_info.vertex_source(cls.base_vertex_shader_2d)
-        shader_info.fragment_source(cls.base_fragment_shader_2d)
-
-        return shader_info
-
-    @staticmethod
-    @cache
-    def uniform_color_3d():
-        if app.version < (3, 5):
-            return gpu.shader.from_builtin("3D_UNIFORM_COLOR")
-        return gpu.shader.from_builtin("UNIFORM_COLOR")
-
-    @staticmethod
-    @cache
-    def point_color_3d():
-        """Get uniform color shader for points. Compatible with all GPU backends."""
-        return gpu.shader.from_builtin("UNIFORM_COLOR")
-
-    @staticmethod
-    @cache
-    def polyline_color_3d():
-        """Get polyline shader for thick lines on all backends."""
-        return gpu.shader.from_builtin("POLYLINE_UNIFORM_COLOR")
-
     @classmethod
     @cache
     def uniform_color_image_2d(cls):
@@ -170,24 +58,10 @@ def uniform_color_image_2d(cls):
         del shader_info
         return shader
 
-    @classmethod
-    @cache
-    def id_line_3d(cls):
-        shader = cls.uniform_color_line_3d()
-        return shader
-
-    @classmethod
-    @cache
-    def uniform_color_line_3d(cls):
-
-        shader_info = cls.get_base_shader_3d_info()
-        shader = create_from_info(shader_info)
-        del shader_info
-        return shader
-
     @staticmethod
     @cache
     def id_shader_3d():
+        """Simple ID shader for selection rendering (both points and lines)."""
         shader_info = GPUShaderCreateInfo()
         shader_info.push_constant("MAT4", "ModelViewProjectionMatrix")
         shader_info.push_constant("VEC4", "color")
@@ -215,44 +89,3 @@ def id_shader_3d():
         shader = create_from_info(shader_info)
         del shader_info
         return shader
-
-    @staticmethod
-    @cache
-    def dashed_uniform_color_3d():
-        vertex_shader = """
-            uniform mat4 ModelViewProjectionMatrix;
-            in vec3 pos;
-            in float arcLength;
-
-            out float v_ArcLength;
-            vec4 project = ModelViewProjectionMatrix * vec4(pos, 1.0f);
-            vec4 offset = vec4(0,0,-0.001,0);
-            void main()
-            {
-                v_ArcLength = arcLength;
-                gl_Position = project + offset;
-            }
-        """
-
-        fragment_shader = """
-            uniform float u_Scale;
-            uniform vec4 color;
-
-            in float v_ArcLength;
-            out vec4 fragColor;
-
-            void main()
-            {
-                if (step(sin(v_ArcLength * u_Scale), 0.7) == 0) discard;
-                fragColor = color;
-            }
-        """
-        return GPUShader(vertex_shader, fragment_shader)
-
-    @classmethod
-    @cache
-    def uniform_color_line_2d(cls):
-        shader_info = cls.get_base_shader_2d_info()
-        shader = create_from_info(shader_info)
-        del shader_info
-        return shader

utilities/draw.py

@@ -9,30 +9,6 @@
 from .constants import FULL_TURN
 
 
-# def draw_circle_2d(cx: float, cy: float, r: float, num_segments: int):
-#     """NOTE: Not used?"""
-#     # circle outline
-#     # NOTE: also see gpu_extras.presets.draw_circle_2d
-#     theta = FULL_TURN / num_segments
-
-#     # precalculate the sine and cosine
-#     c = math.cos(theta)
-#     s = math.sin(theta)
-
-#     # start at angle = 0
-#     x = r
-#     y = 0
-#     coords = []
-#     for _ in range(num_segments):
-#         coords.append((x + cx, y + cy))
-#         # apply the rotation matrix
-#         t = x
-#         x = c * x - s * y
-#         y = s * t + c * y
-#     coords.append(coords[0])
-#     return coords
-
-
 def draw_rect_2d(cx: float, cy: float, width: float, height: float):
     # NOTE: this currently returns xyz coordinates, might make sense to return 2d coords
     ox = cx - (width / 2)

utilities/gpu_manager.py

@@ -54,16 +54,14 @@ def get_id_shader(cls, is_point: bool = False) -> gpu.types.GPUShader:
         """Get cached ID shader for selection rendering."""
         from ..shaders import Shaders
 
-        shader_key = 'id_point' if is_point else 'id_line'
+        # Use single consolidated shader for both points and lines
+        shader_key = 'id_shader'
         if shader_key not in cls._cached_shaders:
             try:
-                if is_point:
-                    cls._cached_shaders[shader_key] = Shaders.id_shader_3d()
-                else:
-                    cls._cached_shaders[shader_key] = Shaders.id_line_3d()
+                cls._cached_shaders[shader_key] = Shaders.id_shader_3d()
                 logger.debug(f"Created shader: {shader_key}")
             except Exception as e:
-                logger.error(f"Failed to create ID shader ({shader_key}): {e}")
+                logger.error(f"Failed to create ID shader: {e}")
                 raise
         return cls._cached_shaders[shader_key]