glplot 0.1.0__py3-none-any.whl

glplot/renderers/axis.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+import numpy as np
+from OpenGL.GL import *
+from typing import TYPE_CHECKING, Optional
+
+from ..utils.shaders import STRIP_VS, STRIP_FS
+from ..utils.gl_utils import link_program
+
+if TYPE_CHECKING:
+    from ..managers.axis import AxisManager
+    from ..core.context import RenderContext
+    from ..options import EngineOptions
+
+class AxisRenderer:
+    """
+    Specialized renderer for the plot framework: grid, spines, and ticks.
+    """
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.prog = 0
+        self.u_mvp = -1
+        self.u_color = -1
+        self.u_alpha = -1
+        
+        # Temp buffer for line drawing
+        self.vbo = 0
+        self.vao = 0
+
+    def initialize(self) -> None:
+        self.prog = link_program(STRIP_VS, STRIP_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.vao = glGenVertexArrays(1)
+        self.vbo = glGenBuffers(1)
+        
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, None)
+        glBindVertexArray(0)
+
+    def draw(self, axis: AxisManager, ctx: RenderContext) -> None:
+        # Check overall visibility
+        if not any([self.options.axis_show_grid, self.options.axis_show_frame, self.options.axis_show_labels]):
+            return
+
+        glUseProgram(self.prog)
+        glUniformMatrix4fv(self.u_mvp, 1, GL_TRUE, ctx.mvp)
+        
+        glBindVertexArray(self.vao)
+        glBindBuffer(GL_ARRAY_BUFFER, self.vbo)
+
+        win = ctx.window_world
+        
+        # 1. Draw Grid
+        if self.options.axis_show_grid:
+            c = self.options.axis_grid_color
+            glUniform4f(self.u_color, c[0], c[1], c[2], self.options.axis_grid_alpha)
+            glUniform1f(self.u_alpha, 1.0)
+            
+            grid_lines = []
+            # Vertical lines (X-ticks)
+            for x in axis.ticks_x.major:
+                grid_lines.extend([(x, win[2]), (x, win[3])])
+            # Horizontal lines (Y-ticks)
+            for y in axis.ticks_y.major:
+                grid_lines.extend([(win[0], y), (win[1], y)])
+                
+            if grid_lines:
+                data = np.array(grid_lines, dtype=np.float32)
+                glBufferData(GL_ARRAY_BUFFER, data.nbytes, data, GL_STREAM_DRAW)
+                glDrawArrays(GL_LINES, 0, len(grid_lines))
+
+        # 2. Draw Spines (Frame)
+        if self.options.axis_show_frame:
+            glUniform4f(self.u_color, 0.2, 0.2, 0.2, 1.0) # Dark spines
+            frame = [
+                (win[0], win[2]), (win[1], win[2]),
+                (win[1], win[2]), (win[1], win[3]),
+                (win[1], win[3]), (win[0], win[3]),
+                (win[0], win[3]), (win[0], win[2])
+            ]
+            data_frame = np.array(frame, dtype=np.float32)
+            glBufferData(GL_ARRAY_BUFFER, data_frame.nbytes, data_frame, GL_STREAM_DRAW)
+            glDrawArrays(GL_LINES, 0, 8)
+        
+        glBindVertexArray(0)
+        glUseProgram(0)
+
+        # 3. Draw Axis Labels (Scale)
+        if self.options.axis_show_labels:
+            self._draw_labels(axis, ctx)
+
+    def _draw_labels(self, axis: AxisManager, ctx: RenderContext) -> None:
+        """Draw numeric labels along the axes."""
+        try:
+            import imgui
+        except ImportError:
+            return
+
+        draw_list = imgui.get_background_draw_list()
+        color = imgui.get_color_u32_rgba(0.2, 0.2, 0.2, 1.0)
+        win = ctx.window_world
+        
+        # Helper to project world to screen
+        def project(wx, wy):
+            pos_world = np.array([wx, wy, 0.0, 1.0], dtype=np.float32)
+            pos_ndc = ctx.mvp @ pos_world
+            if pos_ndc[3] != 0: pos_ndc /= pos_ndc[3]
+            screen_x = (pos_ndc[0] + 1.0) * 0.5 * ctx.width_px
+            screen_y = (1.0 - pos_ndc[1]) * 0.5 * ctx.height_px
+            return screen_x, screen_y
+
+        # X-Axis Labels (along bottom)
+        for val, label in zip(axis.ticks_x.major, axis.ticks_x.labels):
+            sx, sy = project(val, win[2])
+            # Offset labels slightly below the spine
+            draw_list.add_text(sx - 15, sy + 5, color, label)
+
+        # Y-Axis Labels (along left)
+        for val, label in zip(axis.ticks_y.major, axis.ticks_y.labels):
+            sx, sy = project(win[0], val)
+            # Offset labels slightly to the left of the spine
+            draw_list.add_text(sx - 45, sy - 7, color, label)

glplot/renderers/base.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Tuple
+
+@dataclass
+class GLLineBuffers:
+    vao: int = 0
+    vbo_base: int = 0
+    vbo_ab: int = 0
+    vbo_col: int = 0
+    has_color: bool = False
+
+    def render(self, count: int) -> None:
+        from OpenGL.GL import glBindVertexArray, glDrawArraysInstanced, GL_LINES
+        if self.vao and count > 0:
+            glBindVertexArray(self.vao)
+            glDrawArraysInstanced(GL_LINES, 0, 2, count)
+            glBindVertexArray(0)
+
+@dataclass
+class GLScatterBuffers:
+    vao: int = 0
+    vbo_pts: int = 0
+    vbo_col: int = 0
+    count: int = 0
+    size: float = 5.0
+
+@dataclass
+class GLStripBuffers:
+    vao: int = 0
+    vbo_pts: int = 0
+    count: int = 0
+    color: Tuple[float, float, float, float] = (0, 0, 0, 1)
+
+@dataclass
+class GLOffscreenTarget:
+    fbo: int = 0
+    tex: int = 0
+    width: int = 0
+    height: int = 0

glplot/renderers/density.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+import numpy as np
+from OpenGL.GL import *
+from typing import Tuple, Optional, TYPE_CHECKING
+
+from ..utils.shaders import INTERACTION_FULLSCREEN_VS, DENSITY_RESOLVE_FS
+from ..utils.gl_utils import link_program
+from .base import GLOffscreenTarget
+
+if TYPE_CHECKING:
+    from ..options import EngineOptions
+    from ..core.context import RenderContext
+
+class DensityRenderer:
+    """
+    Modular Density Manager for Phase 5.
+    
+    Coordinates the accumulation of density data from multiple primitive
+    renderers into a shared R32F texture, then resolves it into a heatmap.
+    """
+
+    def __init__(self, plot: "GPULinePlot"):
+        self.plot = plot
+        self.options = plot.options
+
+        # Resolve pass
+        self.resolve_prog = 0
+        self.u_resolve_tex = -1
+        self.u_resolve_gain = -1
+        self.u_resolve_scheme = -1
+        self.resolve_vao = 0
+
+        self.accum_target = GLOffscreenTarget()
+        self._clear_zero = np.array([0.0], dtype=np.float32)
+
+    def initialize(self, fb_width: int, fb_height: int) -> None:
+        """Initialize shaders and framebuffer targets."""
+        self.resolve_prog = link_program(INTERACTION_FULLSCREEN_VS, DENSITY_RESOLVE_FS)
+        self.u_resolve_tex = glGetUniformLocation(self.resolve_prog, "u_tex")
+        self.u_resolve_gain = glGetUniformLocation(self.resolve_prog, "u_gain")
+        self.u_resolve_log_scale = glGetUniformLocation(self.resolve_prog, "u_log_scale")
+        self.u_resolve_scheme = glGetUniformLocation(self.resolve_prog, "u_scheme")
+        self.resolve_vao = glGenVertexArrays(1)
+
+        self.rebuild_target(fb_width, fb_height)
+
+    def rebuild_target(self, fb_width: int, fb_height: int) -> None:
+        """Create/Resize the R32F accumulation texture."""
+        if self.accum_target.fbo:
+            glDeleteFramebuffers(1, [self.accum_target.fbo])
+            glDeleteTextures(1, [self.accum_target.tex])
+
+        scale = max(0.05, float(self.options.density_resolution_scale))
+        w = max(1, int(round(fb_width * scale)))
+        h = max(1, int(round(fb_height * scale)))
+
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, w, h, 0, GL_RED, GL_FLOAT, None)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+
+        fbo = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0)
+
+        status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        if status != GL_FRAMEBUFFER_COMPLETE:
+            raise RuntimeError("Density accumulation framebuffer is incomplete")
+
+        self.accum_target = GLOffscreenTarget(fbo=fbo, tex=tex, width=w, height=h)
+
+    def begin_accum(self) -> None:
+        """Prepare the accumulation target for a new frame."""
+        glBindFramebuffer(GL_FRAMEBUFFER, self.accum_target.fbo)
+        glViewport(0, 0, self.accum_target.width, self.accum_target.height)
+        glClearBufferfv(GL_COLOR, 0, self._clear_zero)
+
+        # DENSITY ALWAYS NEEDS ADDITIVE BLENDING for accumulation
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_ONE, GL_ONE)
+
+        # Handle clipping state if enabled globally
+        if self.options.enable_clipping_optimization:
+            glEnable(GL_CLIP_DISTANCE0)
+            glEnable(GL_CLIP_DISTANCE1)
+            glEnable(GL_CLIP_DISTANCE2)
+            glEnable(GL_CLIP_DISTANCE3)
+        else:
+            glDisable(GL_CLIP_DISTANCE0)
+            glDisable(GL_CLIP_DISTANCE1)
+            glDisable(GL_CLIP_DISTANCE2)
+            glDisable(GL_CLIP_DISTANCE3)
+
+    def resolve(self, target_fbo: int = 0, target_size: Optional[Tuple[int, int]] = None) -> None:
+        """Resolve the accumulated density into a color heatmap in the target FBO."""
+        glBindFramebuffer(GL_FRAMEBUFFER, target_fbo)
+        
+        # Robust Viewport Management (Fix for 1/4 size rendering on HighDPI)
+        if target_size is not None:
+            glViewport(0, 0, int(target_size[0]), int(target_size[1]))
+        else:
+            glViewport(0, 0, self.plot.fb_width, self.plot.fb_height)
+
+        glDisable(GL_BLEND)
+        glUseProgram(self.resolve_prog)
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, self.accum_target.tex)
+        glUniform1i(self.u_resolve_tex, 0)
+        glUniform1f(self.u_resolve_gain, float(self.options.density_gain))
+        glUniform1f(self.u_resolve_log_scale, float(self.options.density_log_scale))
+        glUniform1i(self.u_resolve_scheme, self.options.density_scheme_index)
+
+        glBindVertexArray(self.resolve_vao)
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
+        glBindVertexArray(0)
+        glUseProgram(0)

glplot/renderers/exact.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+import ctypes as C
+import numpy as np
+from OpenGL.GL import *
+from typing import Tuple, TYPE_CHECKING
+from ..utils.shaders import EXACT_LINES_VS, EXACT_LINES_FS, SCATTER_VS, SCATTER_FS, STRIP_VS, STRIP_FS
+from ..utils.gl_utils import link_program
+from ..utils.gl_utils import link_program
+from .base import GLLineBuffers, GLScatterBuffers, GLStripBuffers
+
+if TYPE_CHECKING:
+    from ..options import EngineOptions
+    from ..core.legacy import SceneData, LineDataset, ScatterDataset, StripDataset
+
+class ExactLineRenderer:
+    def __init__(self, options: EngineOptions):
+        self.options = options
+        self.prog = 0
+        self.u_mvp = -1
+        self.u_xrange = -1
+        self.u_window = -1
+        self.u_use_color = -1
+        self.u_alpha = -1
+        self.u_enable_sub = -1
+        self.u_keep_prob = -1
+        self.buffers = GLLineBuffers()
+
+        self.scatter_prog = 0
+        self.u_scat_mvp = -1
+        self.u_scat_size = -1
+        self.u_scat_alpha = -1
+
+        self.strip_prog = 0
+        self.u_strip_mvp = -1
+        self.u_strip_color = -1
+        self.u_strip_alpha = -1
+
+        self.use_fp16_ab = True
+        self.use_packed_color = True
+
+    def initialize(self) -> None:
+        self.prog = link_program(EXACT_LINES_VS, EXACT_LINES_FS)
+        self.u_mvp = glGetUniformLocation(self.prog, "u_mvp")
+        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_enable_sub = glGetUniformLocation(self.prog, "u_enable_subsample")
+        self.u_keep_prob = glGetUniformLocation(self.prog, "u_keep_prob")
+        self.u_total_count = glGetUniformLocation(self.prog, "u_total_count")
+        self.u_use_colormap = glGetUniformLocation(self.prog, "u_use_colormap")
+        self.u_scheme = glGetUniformLocation(self.prog, "u_scheme")
+
+        self.scatter_prog = link_program(SCATTER_VS, SCATTER_FS)
+        self.u_scat_mvp = glGetUniformLocation(self.scatter_prog, "u_mvp")
+        self.u_scat_size = glGetUniformLocation(self.scatter_prog, "u_size")
+        self.u_scat_alpha = glGetUniformLocation(self.scatter_prog, "u_alpha")
+
+        self.strip_prog = link_program(STRIP_VS, STRIP_FS)
+        self.u_strip_mvp = glGetUniformLocation(self.strip_prog, "u_mvp")
+        self.u_strip_color = glGetUniformLocation(self.strip_prog, "u_color")
+        self.u_strip_alpha = glGetUniformLocation(self.strip_prog, "u_alpha")
+
+        self.buffers.vao = glGenVertexArrays(1)
+        glBindVertexArray(self.buffers.vao)
+
+        self.buffers.vbo_base = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.buffers.vbo_base)
+        t = np.array([0.0, 1.0], dtype=np.float32)
+        glBufferData(GL_ARRAY_BUFFER, t.nbytes, t, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+
+        self.buffers.vbo_ab = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.buffers.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)
+
+        self.buffers.vbo_col = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, self.buffers.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)
+
+    def upload(self, dataset: LineDataset) -> None:
+        if dataset.ab is None:
+            return
+        dataset.validate()
+        glBindVertexArray(self.buffers.vao)
+
+        ab_u = dataset.ab.astype(np.float16) if self.use_fp16_ab else dataset.ab
+        glBindBuffer(GL_ARRAY_BUFFER, self.buffers.vbo_ab)
+        glBufferData(GL_ARRAY_BUFFER, ab_u.nbytes, ab_u, GL_STATIC_DRAW)
+
+        self.buffers.has_color = dataset.colors is not None
+        if self.buffers.has_color:
+            if self.use_packed_color:
+                cols_u8 = np.clip(dataset.colors * 255.0, 0, 255).astype(np.uint8, copy=False)
+                glBindBuffer(GL_ARRAY_BUFFER, self.buffers.vbo_col)
+                glBufferData(GL_ARRAY_BUFFER, cols_u8.nbytes, cols_u8, GL_STATIC_DRAW)
+            else:
+                glBindBuffer(GL_ARRAY_BUFFER, self.buffers.vbo_col)
+                glBufferData(GL_ARRAY_BUFFER, dataset.colors.nbytes, dataset.colors, GL_STATIC_DRAW)
+
+        glBindVertexArray(0)
+
+    def draw(
+        self,
+        scene: SceneData,
+        mvp: np.ndarray,
+        window: Tuple[float, float, float, float],
+        global_alpha: float,
+        lod_keep_prob: float,
+        clipping_enabled: bool,
+    ) -> None:
+        # 1. Draw main lines
+        dataset = scene.lines
+        if dataset.ab is not None and dataset.count > 0:
+            l, r, b, t = window
+            glUseProgram(self.prog)
+            glUniformMatrix4fv(self.u_mvp, 1, GL_TRUE, mvp)
+            glUniform2f(self.u_xrange, float(dataset.x_range[0]), float(dataset.x_range[1]))
+            glUniform4f(self.u_window, l, r, b, t)
+            glUniform1i(self.u_use_color, 1 if self.buffers.has_color else 0)
+            glUniform1f(self.u_alpha, float(global_alpha))
+            glUniform1i(self.u_enable_sub, 1 if lod_keep_prob < 1.0 else 0)
+            glUniform1f(self.u_keep_prob, float(lod_keep_prob))
+            glUniform1i(self.u_total_count, dataset.count)
+            glUniform1i(self.u_use_colormap, 1 if self.options.line_colormap_enabled else 0)
+            glUniform1i(self.u_scheme, self.options.density_scheme_index)
+
+            if clipping_enabled:
+                glEnable(GL_CLIP_DISTANCE0)
+                glEnable(GL_CLIP_DISTANCE1)
+                glEnable(GL_CLIP_DISTANCE2)
+                glEnable(GL_CLIP_DISTANCE3)
+            else:
+                glDisable(GL_CLIP_DISTANCE0)
+                glDisable(GL_CLIP_DISTANCE1)
+                glDisable(GL_CLIP_DISTANCE2)
+                glDisable(GL_CLIP_DISTANCE3)
+
+            glBindVertexArray(self.buffers.vao)
+            glDrawArraysInstanced(GL_LINES, 0, 2, dataset.count)
+            glBindVertexArray(0)
+            glUseProgram(0)
+
+        # 2. Draw scatters
+        if scene.scatters:
+            glUseProgram(self.scatter_prog)
+            glEnable(GL_PROGRAM_POINT_SIZE)
+            glUniformMatrix4fv(self.u_scat_mvp, 1, GL_TRUE, mvp)
+            glUniform1f(self.u_scat_alpha, float(global_alpha))
+            for scat in scene.scatters:
+                if not hasattr(scat, '_gl'):
+                    scat._gl = self._create_scatter_buffers(scat)
+                glUniform1f(self.u_scat_size, float(scat.size))
+                glBindVertexArray(scat._gl.vao)
+                glDrawArrays(GL_POINTS, 0, scat._gl.count)
+            glBindVertexArray(0)
+            glUseProgram(0)
+
+        # 3. Draw line strips
+        if scene.strips:
+            glUseProgram(self.strip_prog)
+            glUniformMatrix4fv(self.u_strip_mvp, 1, GL_TRUE, mvp)
+            glUniform1f(self.u_strip_alpha, float(global_alpha))
+            for strip in scene.strips:
+                if not hasattr(strip, '_gl'):
+                    strip._gl = self._create_strip_buffers(strip)
+                glUniform4f(self.u_strip_color, *strip.color)
+                glBindVertexArray(strip._gl.vao)
+                glDrawArrays(GL_LINE_STRIP, 0, strip._gl.count)
+            glBindVertexArray(0)
+            glUseProgram(0)
+
+    def _create_scatter_buffers(self, scat: ScatterDataset) -> GLScatterBuffers:
+        vao = glGenVertexArrays(1)
+        glBindVertexArray(vao)
+        vbo_pts = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_pts)
+        glBufferData(GL_ARRAY_BUFFER, scat.pts.nbytes, scat.pts, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+
+        vbo_col = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_col)
+        glBufferData(GL_ARRAY_BUFFER, scat.colors.nbytes, scat.colors, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(1)
+        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+
+        glBindVertexArray(0)
+        return GLScatterBuffers(vao=vao, vbo_pts=vbo_pts, vbo_col=vbo_col, count=len(scat.pts), size=scat.size)
+
+    def _create_strip_buffers(self, strip: StripDataset) -> GLStripBuffers:
+        vao = glGenVertexArrays(1)
+        glBindVertexArray(vao)
+        vbo_pts = glGenBuffers(1)
+        glBindBuffer(GL_ARRAY_BUFFER, vbo_pts)
+        glBufferData(GL_ARRAY_BUFFER, strip.pts.nbytes, strip.pts, GL_STATIC_DRAW)
+        glEnableVertexAttribArray(0)
+        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, C.c_void_p(0))
+        glBindVertexArray(0)
+        return GLStripBuffers(vao=vao, vbo_pts=vbo_pts, count=len(strip.pts), color=strip.color)

glplot/renderers/interaction.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from OpenGL.GL import *
+from typing import Tuple, TYPE_CHECKING
+from ..utils.shaders import INTERACTION_FULLSCREEN_VS, CACHE_IMPOSTOR_FS
+from ..utils.gl_utils import link_program
+from .base import GLOffscreenTarget
+
+if TYPE_CHECKING:
+    from ..options import EngineOptions
+    from ..engine import GPULinePlot
+
+class InteractionRenderer:
+    """
+    Interaction rendering should never compromise frame pacing.
+
+    This renderer supports two lightweight interaction paths:
+    1. cached impostor reprojection
+    2. density/aggregate interaction image (placeholder for expansion)
+    """
+
+    def __init__(self, plot: "GPULinePlot"):
+        self.plot = plot
+        self.options = plot.options
+        self.cache_prog = 0
+        self.u_cache_tex = -1
+        self.u_cache_window = -1
+        self.u_cur_window = -1
+        self.cache_vao = 0
+        self.cache_target = GLOffscreenTarget()
+
+    def initialize(self, fb_width: int, fb_height: int) -> None:
+        self.cache_prog = link_program(INTERACTION_FULLSCREEN_VS, CACHE_IMPOSTOR_FS)
+        self.u_cache_tex = glGetUniformLocation(self.cache_prog, "u_tex")
+        self.u_cache_window = glGetUniformLocation(self.cache_prog, "u_cache_window")
+        self.u_cur_window = glGetUniformLocation(self.cache_prog, "u_cur_window")
+        self.cache_vao = glGenVertexArrays(1)
+        self.rebuild_cache_target(fb_width, fb_height)
+
+    def rebuild_cache_target(self, fb_width: int, fb_height: int) -> None:
+        if self.cache_target.fbo:
+            glDeleteFramebuffers(1, [self.cache_target.fbo])
+            glDeleteTextures(1, [self.cache_target.tex])
+
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, fb_width, fb_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+
+        fbo = glGenFramebuffers(1)
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0)
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+
+        self.cache_target = GLOffscreenTarget(fbo=fbo, tex=tex, width=fb_width, height=fb_height)
+
+    def draw_cached_impostor(
+        self,
+        capture_window: Tuple[float, float, float, float],
+        current_window: Tuple[float, float, float, float],
+    ) -> None:
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+        glViewport(0, 0, self.plot.fb_width, self.plot.fb_height)
+        glEnable(GL_BLEND)
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+        glUseProgram(self.cache_prog)
+        glActiveTexture(GL_TEXTURE0)
+        glBindTexture(GL_TEXTURE_2D, self.cache_target.tex)
+        glUniform1i(self.u_cache_tex, 0)
+        glUniform4f(self.u_cache_window, *capture_window)
+        glUniform4f(self.u_cur_window, *current_window)
+        glBindVertexArray(self.cache_vao)
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
+        glBindVertexArray(0)
+        glUseProgram(0)