glplot 0.1.0__py3-none-any.whl

glplot/renderers/line_family.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+import ctypes as C
+import numpy as np
+from OpenGL.GL import *
+from typing import TYPE_CHECKING, Optional, Tuple
+
+from .base import GLLineBuffers
+from ..utils.shaders import WIDE_LINES_INSTANCED_VS, EXACT_LINES_FS, DENSITY_ACCUM_FS
+from ..utils.gl_utils import link_program
+
+if TYPE_CHECKING:
+    from ..core.layers import LineFamilyLayer
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+class LineFamilyRenderer:
+    """
+    Primitive renderer for LineFamilyLayer.
+    Specialized for high-performance instanced rendering of lines via quad expansion.
+    Uses optimized orthographic shaders for maximum throughput.
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.prog = 0
+        
+        # Uniform locations (Exact)
+        self.u_ndc_scale = -1
+        self.u_ndc_offset = -1
+        self.u_xrange = -1
+        self.u_window = -1
+        self.u_use_color = -1
+        self.u_alpha = -1
+        self.u_width = -1
+        self.u_viewport = -1
+        self.u_keep_prob = -1
+        self.u_total_count = -1
+        self.u_offset = -1
+        self.u_use_colormap = -1
+        self.u_scheme = -1
+        
+        # Accumulation uniforms
+        self.accum_prog = 0
+        self.u_accum_ndc_scale = -1
+        self.u_accum_ndc_offset = -1
+        self.u_accum_xrange = -1
+        self.u_accum_window = -1
+        self.u_accum_use_color = -1
+        self.u_accum_alpha = -1
+        self.u_accum_width = -1
+        self.u_accum_viewport = -1
+        self.u_accum_keep_prob = -1
+        self.u_accum_offset = -1
+
+        # Configuration
+        self.use_fp16_ab = True
+        self.use_packed_color = True
+
+    def initialize(self) -> None:
+        """Link wide-line instanced shaders and setup uniform locations."""
+        self.prog = link_program(WIDE_LINES_INSTANCED_VS, EXACT_LINES_FS)
+        self.u_ndc_scale = glGetUniformLocation(self.prog, "u_ndc_scale")
+        self.u_ndc_offset = glGetUniformLocation(self.prog, "u_ndc_offset")
+        self.u_xrange = glGetUniformLocation(self.prog, "u_xrange")
+        self.u_window = glGetUniformLocation(self.prog, "u_window")
+        self.u_use_color = glGetUniformLocation(self.prog, "u_use_color")
+        self.u_alpha = glGetUniformLocation(self.prog, "u_alpha")
+        self.u_width = glGetUniformLocation(self.prog, "u_width")
+        self.u_viewport = glGetUniformLocation(self.prog, "u_viewport_size")
+        self.u_keep_prob = glGetUniformLocation(self.prog, "u_keep_prob")
+        self.u_total_count = glGetUniformLocation(self.prog, "u_total_count")
+        self.u_offset = glGetUniformLocation(self.prog, "u_layer_offset")
+        self.u_use_colormap = glGetUniformLocation(self.prog, "u_use_colormap")
+        self.u_scheme = glGetUniformLocation(self.prog, "u_scheme")
+
+        # Density Accumulation Program
+        self.accum_prog = link_program(WIDE_LINES_INSTANCED_VS, DENSITY_ACCUM_FS)
+        self.u_accum_ndc_scale = glGetUniformLocation(self.accum_prog, "u_ndc_scale")
+        self.u_accum_ndc_offset = glGetUniformLocation(self.accum_prog, "u_ndc_offset")
+        self.u_accum_xrange = glGetUniformLocation(self.accum_prog, "u_xrange")
+        self.u_accum_window = glGetUniformLocation(self.accum_prog, "u_window")
+        self.u_accum_use_color = glGetUniformLocation(self.accum_prog, "u_use_color")
+        self.u_accum_alpha = glGetUniformLocation(self.accum_prog, "u_alpha")
+        self.u_accum_width = glGetUniformLocation(self.accum_prog, "u_width")
+        self.u_accum_viewport = glGetUniformLocation(self.accum_prog, "u_viewport_size")
+        self.u_accum_keep_prob = glGetUniformLocation(self.accum_prog, "u_keep_prob")
+        self.u_accum_offset = glGetUniformLocation(self.accum_prog, "u_layer_offset")
+
+    def _create_buffers(self, layer: LineFamilyLayer) -> GLLineBuffers:
+        """Create and initialize GPU buffers for a quad-expanded line family."""
+        bufs = GLLineBuffers()
+        bufs.vao = glGenVertexArrays(1)
+        glBindVertexArray(bufs.vao)
+
+        # 1. Base vertex buffer (a_corner: [t, side] x 4)
+        # t in {0,1}, side in {-0.5, 0.5}
+        bufs.vbo_base = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_base)
+        quad_data = np.array([
+            0.0, -0.5,
+            0.0,  0.5,
+            1.0, -0.5,
+            1.0,  0.5
+        ], dtype=np.float32)
+        glBufferData(GL_ARRAY_BUFFER, quad_data.nbytes, quad_data, GL_STATIC_DRAW)
+        
+        # a_corner (loc 0)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 8, C.c_void_p(0))
+
+        # 2. Instanced line parameters (a, b) (loc 1)
+        bufs.vbo_ab = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_ab)
+        glBufferData(GL_ARRAY_BUFFER, 16, None, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(1)
+        if self.use_fp16_ab:
+            glVertexAttribPointer(1, 2, GL_HALF_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        else:
+            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        glVertexAttribDivisor(1, 1)
+
+        # 3. Instanced colors (loc 2)
+        bufs.vbo_col = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_col)
+        glBufferData(GL_ARRAY_BUFFER, 16, None, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(2)
+        if self.use_packed_color:
+            glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, C.c_void_p(0))
+        else:
+            glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        glVertexAttribDivisor(2, 1)
+
+        glBindVertexArray(0)
+        return bufs
+
+    def update_gpu_data(self, layer: LineFamilyLayer, bufs: GLLineBuffers) -> None:
+        """Upload semantic data to GPU buffers."""
+        if layer.ab is None: return
+        
+        glBindVertexArray(bufs.vao)
+
+        # Upload AB
+        ab_u = layer.ab.astype(np.float16) if self.use_fp16_ab else layer.ab
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_ab)
+        glBufferData(GL_ARRAY_BUFFER, ab_u.nbytes, ab_u, GL_STATIC_DRAW)
+
+        # Upload Colors
+        bufs.has_color = layer.colors is not None
+        if bufs.has_color:
+            if self.use_packed_color:
+                cols_u8 = np.clip(layer.colors * 255.0, 0, 255).astype(np.uint8, copy=False)
+                glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_col)
+                glBufferData(GL_ARRAY_BUFFER, cols_u8.nbytes, cols_u8, GL_STATIC_DRAW)
+            else:
+                glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_col)
+                glBufferData(GL_ARRAY_BUFFER, layer.colors.nbytes, layer.colors, GL_STATIC_DRAW)
+
+        glBindVertexArray(0)
+        layer.dirty.gpu_dirty = False
+
+    def draw(self, layer: LineFamilyLayer, ctx: RenderContext) -> None:
+        """Draw the layer using current context."""
+        if layer.ab is None or len(layer.ab) == 0: return
+
+        # 1. Resource Management
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        # 2. Setup Shaders & Uniforms
+        glUseProgram(self.prog)
+        glUniform2f(self.u_ndc_scale, *ctx.ndc_scale)
+        glUniform2f(self.u_ndc_offset, *ctx.ndc_offset)
+        glUniform2f(self.u_viewport, float(ctx.fb_width), float(ctx.fb_height))
+        glUniform2f(self.u_xrange, float(layer.x_range[0]), float(layer.x_range[1]))
+        glUniform4f(self.u_window, *ctx.window_world)
+        glUniform1i(self.u_use_color, 1 if layer._gl.has_color else 0)
+        
+        # Style Application
+        overrides = self.options.visual.overrides
+        alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+        glUniform1f(self.u_alpha, float(alpha))
+        
+        width = layer.style.line_width * overrides.line_width_multiplier
+        glUniform1f(self.u_width, float(width))
+        
+        # LOD
+        prob = ctx.lod_keep_prob
+        glUniform1f(self.u_keep_prob, float(prob))
+        glUniform1i(self.u_total_count, len(layer.ab))
+        glUniform2f(self.u_offset, *layer.translation)
+        
+        # Colormap
+        glUniform1i(self.u_use_colormap, 1 if self.options.line_colormap_enabled else 0)
+        glUniform1i(self.u_scheme, self.options.density_scheme_index)
+
+        # 3. Draw call (Instanced Quads)
+        glBindVertexArray(layer._gl.vao)
+        glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, len(layer.ab))
+        
+        # Cleanup
+        glBindVertexArray(0)
+        glUseProgram(0)
+
+    def draw_density(self, layer: LineFamilyLayer, ctx: RenderContext) -> None:
+        """Accumulate line density into the current R32F target."""
+        if layer.ab is None or len(layer.ab) == 0: return
+
+        # 1. Resource Management
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        # 2. Setup Shaders
+        glUseProgram(self.accum_prog)
+        glUniform2f(self.u_accum_ndc_scale, *ctx.ndc_scale)
+        glUniform2f(self.u_accum_ndc_offset, *ctx.ndc_offset)
+        glUniform2f(self.u_accum_viewport, float(ctx.fb_width), float(ctx.fb_height))
+        glUniform2f(self.u_accum_xrange, float(layer.x_range[0]), float(layer.x_range[1]))
+        glUniform4f(self.u_accum_window, *ctx.window_world)
+        
+        overrides = self.options.visual.overrides
+        width = max(1.0, layer.style.line_width * overrides.line_width_multiplier)
+        glUniform1f(self.u_accum_width, float(width))
+        
+        if self.options.density_weighted:
+            glUniform1i(self.u_accum_use_color, 1 if layer._gl.has_color else 0)
+            alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+            glUniform1f(self.u_accum_alpha, float(alpha))
+        else:
+            glUniform1i(self.u_accum_use_color, 0)
+            glUniform1f(self.u_accum_alpha, 1.0)
+
+        # LOD
+        prob = ctx.lod_keep_prob
+        glUniform1f(self.u_accum_keep_prob, float(prob))
+        glUniform2f(self.u_accum_offset, *layer.translation)
+
+        # 3. Draw call
+        glBindVertexArray(layer._gl.vao)
+        glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, len(layer.ab))
+        
+        # Cleanup
+        glBindVertexArray(0)
+        glUseProgram(0)

glplot/renderers/patch.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+import ctypes as C
+import numpy as np
+from OpenGL.GL import *
+from typing import TYPE_CHECKING, Optional, Tuple
+
+from ..utils.shaders import PATCH_VS, PATCH_FS, DENSITY_ACCUM_FS
+from ..utils.gl_utils import link_program
+
+if TYPE_CHECKING:
+    from ..core.layers import PatchLayer
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+class GLPatchBuffers:
+    def __init__(self, vao: int, vbo: int, ebo: Optional[int] = None):
+        self.vao = vao
+        self.vbo = vbo
+        self.ebo = ebo
+        self.count = 0
+
+class PatchRenderer:
+    """
+    Primitive renderer for PatchLayer.
+    Specialized for area fills, bars, and bands using GL_TRIANGLE_STRIP/TRIANGLES.
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.prog = 0
+        self.u_mvp = -1
+        self.u_color = -1
+        self.u_alpha = -1
+        self.u_offset = -1
+
+    def initialize(self) -> None:
+        self.prog = link_program(PATCH_VS, PATCH_FS)
+        self.u_mvp = glGetUniformLocation(self.prog, "u_mvp")
+        self.u_color = glGetUniformLocation(self.prog, "u_color")
+        self.u_alpha = glGetUniformLocation(self.prog, "u_alpha")
+        self.u_offset = glGetUniformLocation(self.prog, "u_layer_offset")
+
+        # Density accumulation (Triangles into R32F)
+        self.accum_prog = link_program(PATCH_VS, DENSITY_ACCUM_FS)
+        self.u_accum_mvp = glGetUniformLocation(self.accum_prog, "u_mvp")
+        self.u_accum_alpha = glGetUniformLocation(self.accum_prog, "u_alpha")
+        self.u_accum_weighted = glGetUniformLocation(self.accum_prog, "u_density_weighted")
+
+    def _create_buffers(self, layer: PatchLayer) -> GLPatchBuffers:
+        vao = glGenVertexArrays(1)
+        glBindVertexArray(vao)
+        
+        vbo = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        
+        ebo = None
+        if layer.indices is not None:
+            ebo = glGenBuffers(1)
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
+        
+        glBindVertexArray(0)
+        return GLPatchBuffers(vao, vbo, ebo)
+
+    def update_gpu_data(self, layer: PatchLayer, bufs: GLPatchBuffers) -> None:
+        if layer.vertices is None or len(layer.vertices) == 0: return
+        
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo)
+        glBufferData(GL_ARRAY_BUFFER, layer.vertices.nbytes, layer.vertices, GL_STATIC_DRAW)
+        
+        if layer.indices is not None and bufs.ebo is not None:
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufs.ebo)
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, layer.indices.nbytes, layer.indices, GL_STATIC_DRAW)
+            bufs.count = len(layer.indices)
+        else:
+            bufs.count = len(layer.vertices)
+            
+        layer.dirty.gpu_dirty = False
+
+    def draw(self, layer: PatchLayer, ctx: RenderContext) -> None:
+        if layer.vertices is None or len(layer.vertices) == 0: return
+
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        glUseProgram(self.prog)
+        glUniformMatrix4fv(self.u_mvp, 1, GL_TRUE, ctx.mvp)
+        
+        overrides = self.options.visual.overrides
+        alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+        glUniform1f(self.u_alpha, float(alpha))
+        glUniform2f(self.u_offset, *layer.translation)
+        
+        # Draw face
+        if layer.style.face_color is not None:
+            glUniform4f(self.u_color, *layer.style.face_color)
+            glBindVertexArray(layer._gl.vao)
+            
+            mode = GL_TRIANGLE_STRIP
+            if layer.mode == "triangles": mode = GL_TRIANGLES
+            
+            if layer._gl.ebo is not None:
+                glDrawElements(mode, layer._gl.count, GL_UNSIGNED_INT, None)
+            else:
+                glDrawArrays(mode, 0, layer._gl.count)
+                
+        glBindVertexArray(0)
+        glUseProgram(0)
+
+    def draw_density(self, layer: PatchLayer, ctx: RenderContext) -> None:
+        """Accumulate patch area into density heatmap."""
+        if layer.vertices is None or len(layer.vertices) == 0: return
+
+        # 1. Resource Management
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        # 2. Setup Shaders
+        glUseProgram(self.accum_prog)
+        glUniformMatrix4fv(self.u_accum_mvp, 1, GL_TRUE, ctx.mvp)
+        
+        overrides = self.options.visual.overrides
+        if self.options.density_weighted:
+            glUniform1i(self.u_accum_weighted, 1)
+            alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+            glUniform1f(self.u_accum_alpha, float(alpha))
+        else:
+            glUniform1i(self.u_accum_weighted, 0)
+            glUniform1f(self.u_accum_alpha, 1.0)
+
+        # 3. Draw call
+        glBindVertexArray(layer._gl.vao)
+        mode = GL_TRIANGLE_STRIP
+        if layer.mode == "triangles": mode = GL_TRIANGLES
+        
+        if layer._gl.ebo is not None:
+            glDrawElements(mode, layer._gl.count, GL_UNSIGNED_INT, None)
+        else:
+            glDrawArrays(mode, 0, layer._gl.count)
+            
+        glBindVertexArray(0)
+        glUseProgram(0)

glplot/renderers/polyline.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+import ctypes as C
+import numpy as np
+from OpenGL.GL import *
+from typing import TYPE_CHECKING
+from dataclasses import dataclass
+
+from ..utils.gl_utils import link_program
+from ..utils.shaders import (
+    WIDE_SEGMENT_INSTANCED_VS,
+    WIDE_SEGMENT_INSTANCED_FS,
+    WIDE_SEGMENT_DENSITY_FS,
+)
+
+if TYPE_CHECKING:
+    from ..core.layers import PolylineLayer
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+@dataclass
+class GLWideSegmentBuffers:
+    vao: int = 0
+    vbo_quad: int = 0
+    vbo_inst: int = 0
+    ebo: int = 0
+    instance_count: int = 0
+
+class PolylineRenderer:
+    """
+    High-performance renderer for PolylineLayer using GPU Instancing.
+    Replaces the older CPU-side expansion logic.
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+
+        self.prog = 0
+        self.u_ndc_scale = -1
+        self.u_ndc_offset = -1
+        self.u_viewport = -1
+        self.u_width = -1
+        self.u_color = -1
+        self.u_alpha = -1
+        self.u_offset = -1
+        self.u_use_colormap = -1
+        self.u_scheme = -1
+        self.u_id_norm = -1
+
+        self.accum_prog = 0
+        self.u_acc_ndc_scale = -1
+        self.u_acc_ndc_offset = -1
+        self.u_acc_viewport = -1
+        self.u_acc_width = -1
+        self.u_acc_alpha = -1
+        self.u_acc_weighted = -1
+        self.u_acc_offset = -1
+
+    def initialize(self) -> None:
+        self.prog = link_program(WIDE_SEGMENT_INSTANCED_VS, WIDE_SEGMENT_INSTANCED_FS)
+        self.u_ndc_scale = glGetUniformLocation(self.prog, "u_ndc_scale")
+        self.u_ndc_offset = glGetUniformLocation(self.prog, "u_ndc_offset")
+        self.u_viewport = glGetUniformLocation(self.prog, "u_viewport_size")
+        self.u_width = glGetUniformLocation(self.prog, "u_width")
+        self.u_color = glGetUniformLocation(self.prog, "u_color")
+        self.u_alpha = glGetUniformLocation(self.prog, "u_alpha")
+        self.u_offset = glGetUniformLocation(self.prog, "u_layer_offset")
+        self.u_use_colormap = glGetUniformLocation(self.prog, "u_use_colormap")
+        self.u_scheme = glGetUniformLocation(self.prog, "u_scheme")
+        self.u_id_norm = glGetUniformLocation(self.prog, "u_id_norm")
+
+        self.accum_prog = link_program(WIDE_SEGMENT_INSTANCED_VS, WIDE_SEGMENT_DENSITY_FS)
+        self.u_acc_ndc_scale = glGetUniformLocation(self.accum_prog, "u_ndc_scale")
+        self.u_acc_ndc_offset = glGetUniformLocation(self.accum_prog, "u_ndc_offset")
+        self.u_acc_viewport = glGetUniformLocation(self.accum_prog, "u_viewport_size")
+        self.u_acc_width = glGetUniformLocation(self.accum_prog, "u_width")
+        self.u_acc_alpha = glGetUniformLocation(self.accum_prog, "u_alpha")
+        self.u_acc_weighted = glGetUniformLocation(self.accum_prog, "u_density_weighted")
+        self.u_acc_offset = glGetUniformLocation(self.accum_prog, "u_layer_offset")
+
+    def _create_buffers(self, layer: PolylineLayer) -> GLWideSegmentBuffers:
+        vao = glGenVertexArrays(1)
+        glBindVertexArray(vao)
+
+        # Static quad corners: (t, side)
+        # t in [0, 1] goes from start to end of segment
+        # side in [-0.5, 0.5] handles expansion around centerline
+        quad = np.array([
+            [0.0, -0.5],
+            [0.0,  0.5],
+            [1.0, -0.5],
+            [1.0,  0.5],
+        ], dtype=np.float32)
+
+        indices = np.array([0, 1, 2,  2, 1, 3], dtype=np.uint16)
+
+        vbo_quad = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_quad)
+        glBufferData(GL_ARRAY_BUFFER, quad.nbytes, quad, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 8, C.c_void_p(0))
+
+        ebo = glGenBuffers(1)
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW)
+
+        # Per-instance segment buffer: [p0.x, p0.y, p1.x, p1.y]
+        vbo_inst = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_inst)
+        glBufferData(GL_ARRAY_BUFFER, 16, None, GL_STREAM_DRAW) # Initial tiny allocation
+
+        stride = 4 * 4
+        # i_p0 (location 1)
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, stride, C.c_void_p(0))
+        glVertexAttribDivisor(1, 1)
+
+        # i_p1 (location 2)
+        glEnableVertexAttribArray(2)
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, stride, C.c_void_p(8))
+        glVertexAttribDivisor(2, 1)
+
+        glBindVertexArray(0)
+        return GLWideSegmentBuffers(
+            vao=vao,
+            vbo_quad=vbo_quad,
+            vbo_inst=vbo_inst,
+            ebo=ebo,
+            instance_count=0,
+        )
+
+    def update_gpu_data(self, layer: PolylineLayer, bufs: GLWideSegmentBuffers) -> None:
+        if layer.pts is None or len(layer.pts) < 2:
+            bufs.instance_count = 0
+            layer.dirty.gpu_dirty = False
+            return
+
+        # Prepare segment data [p0x, p0y, p1x, p1y]
+        pts = np.ascontiguousarray(layer.pts, dtype=np.float32)
+        segs = np.empty((len(pts) - 1, 4), dtype=np.float32)
+        segs[:, 0:2] = pts[:-1]
+        segs[:, 2:4] = pts[1:]
+
+        glBindBuffer(GL_ARRAY_BUFFER, bufs.vbo_inst)
+        
+        # Buffer Orphaning for performance
+        glBufferData(GL_ARRAY_BUFFER, segs.nbytes, None, GL_STREAM_DRAW)
+        glBufferSubData(GL_ARRAY_BUFFER, 0, segs.nbytes, segs)
+
+        bufs.instance_count = len(segs)
+        layer.dirty.gpu_dirty = False
+
+    def draw(self, layer: PolylineLayer, ctx: RenderContext, id_norm: float = 0.0) -> None:
+        if layer.pts is None or len(layer.pts) < 2:
+            return
+
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        overrides = self.options.visual.overrides
+        width_px = max(1.0, layer.style.line_width * overrides.line_width_multiplier)
+        alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+        color = layer.style.color if layer.style.color is not None else (0.0, 0.0, 0.0, 1.0)
+
+        glUseProgram(self.prog)
+        glUniform2f(self.u_ndc_scale, *ctx.ndc_scale)
+        glUniform2f(self.u_ndc_offset, *ctx.ndc_offset)
+        glUniform2f(self.u_viewport, float(ctx.fb_width), float(ctx.fb_height))
+        glUniform1f(self.u_width, float(width_px))
+        glUniform4f(self.u_color, *color)
+        glUniform1f(self.u_alpha, float(alpha))
+        glUniform2f(self.u_offset, *layer.translation)
+        
+        glUniform1i(self.u_use_colormap, 1 if self.options.line_colormap_enabled else 0)
+        glUniform1i(self.u_scheme, self.options.density_scheme_index)
+        glUniform1f(self.u_id_norm, float(id_norm))
+
+        glBindVertexArray(layer._gl.vao)
+        glDrawElementsInstanced(
+            GL_TRIANGLES,
+            6,
+            GL_UNSIGNED_SHORT,
+            C.c_void_p(0),
+            layer._gl.instance_count
+        )
+        glBindVertexArray(0)
+        glUseProgram(0)
+
+    def draw_density(self, layer: PolylineLayer, ctx: RenderContext) -> None:
+        if layer.pts is None or len(layer.pts) < 2:
+            return
+
+        if not hasattr(layer, "_gl") or layer._gl is None:
+            layer._gl = self._create_buffers(layer)
+            layer.dirty.gpu_dirty = True
+
+        if layer.dirty.gpu_dirty:
+            self.update_gpu_data(layer, layer._gl)
+
+        overrides = self.options.visual.overrides
+        width_px = max(1.0, layer.style.line_width * overrides.line_width_multiplier)
+
+        if self.options.density_weighted:
+            alpha = ctx.global_alpha * layer.style.alpha * overrides.alpha_multiplier
+            weighted = 1
+        else:
+            alpha = 1.0
+            weighted = 0
+
+        glUseProgram(self.accum_prog)
+        glUniform2f(self.u_acc_ndc_scale, *ctx.ndc_scale)
+        glUniform2f(self.u_acc_ndc_offset, *ctx.ndc_offset)
+        glUniform2f(self.u_acc_viewport, float(ctx.fb_width), float(ctx.fb_height))
+        glUniform1f(self.u_acc_width, float(width_px))
+        glUniform1f(self.u_acc_alpha, float(alpha))
+        glUniform1i(self.u_acc_weighted, weighted)
+        glUniform2f(self.u_acc_offset, *layer.translation)
+
+        glBindVertexArray(layer._gl.vao)
+        glDrawElementsInstanced(
+            GL_TRIANGLES,
+            6,
+            GL_UNSIGNED_SHORT,
+            C.c_void_p(0),
+            layer._gl.instance_count
+        )
+        glBindVertexArray(0)
+        glUseProgram(0)