ncca-ngl 0.3.5__py3-none-any.whl → 0.5.1__py3-none-any.whl

ncca/ngl/webgpu/line_pipeline.py

@@ -0,0 +1,405 @@
+"""
+Generic line rendering pipeline for WebGPU.
+Handles line rendering with customizable color and projection.
+"""
+
+from typing import Optional, Tuple
+
+import numpy as np
+import wgpu
+
+from .base_webgpu_pipeline import BaseWebGPUPipeline
+from .pipeline_shaders import LINE_SHADER_MULTI_COLOURED, LINE_SHADER_SINGLE_COLOUR
+from .webgpu_constants import NGLToWebGPU
+
+
+class BaseLinePipeline(BaseWebGPUPipeline):
+    """Base class for line rendering pipelines."""
+
+    def __init__(
+        self,
+        device: wgpu.GPUDevice,
+        data_type: str = "Vec3",
+        texture_format: wgpu.TextureFormat = wgpu.TextureFormat.rgba8unorm,
+        depth_format: wgpu.TextureFormat = wgpu.TextureFormat.depth24plus,
+        msaa_sample_count: int = 4,
+        stride: int = 0,
+        topology: wgpu.PrimitiveTopology = wgpu.PrimitiveTopology.line_list,
+    ):
+        """
+        Initialize the base line pipeline.
+
+        Args:
+            device: WebGPU device
+            texture_format: Color attachment format
+            depth_format: Depth attachment format
+            msaa_sample_count: Number of MSAA samples
+            stride: The stride of the vertex buffer. If 0, it is inferred from data_type.
+            topology: Primitive topology (line_list or line_strip)
+        """
+        self._topology = topology
+        super().__init__(
+            device=device,
+            texture_format=texture_format,
+            depth_format=depth_format,
+            msaa_sample_count=msaa_sample_count,
+            data_type=data_type,
+            stride=stride,
+        )
+
+    def _get_primitive_topology(self) -> wgpu.PrimitiveTopology:
+        """Line pipelines use configurable topology."""
+        return self._topology
+
+
+class LinePipelineMultiColour(BaseLinePipeline):
+    """
+    A reusable pipeline for rendering lines in WebGPU with per-vertex colors.
+
+    Features:
+    - Line strips or line segments
+    - Per-vertex colors
+    - MVP matrix support
+    - MSAA support
+    """
+
+    def __init__(
+        self,
+        device: wgpu.GPUDevice,
+        data_type: str = "Vec3",
+        texture_format: wgpu.TextureFormat = wgpu.TextureFormat.rgba8unorm,
+        depth_format: wgpu.TextureFormat = wgpu.TextureFormat.depth24plus,
+        msaa_sample_count: int = 4,
+        stride: int = 0,
+        topology: wgpu.PrimitiveTopology = wgpu.PrimitiveTopology.line_list,
+    ):
+        """
+        Initialize the line rendering pipeline.
+
+        Args:
+            device: WebGPU device
+            texture_format: Color attachment format
+            depth_format: Depth attachment format
+            msaa_sample_count: Number of MSAA samples
+            stride: The stride of the vertex buffer. If 0, it is inferred from data_type.
+            topology: Primitive topology (line_list or line_strip)
+        """
+        # Pipeline-specific buffer tracking
+        self.vertex_buffer: Optional[wgpu.GPUBuffer] = None
+        self.color_buffer: Optional[wgpu.GPUBuffer] = None
+        self.num_vertices: int = 0
+
+        super().__init__(
+            device=device,
+            texture_format=texture_format,
+            depth_format=depth_format,
+            msaa_sample_count=msaa_sample_count,
+            data_type=data_type,
+            stride=stride,
+            topology=topology,
+        )
+
+    def get_dtype(self) -> np.dtype:
+        """Get the data type of the pipeline."""
+        return np.dtype(
+            [
+                ("MVP", "float32", (4, 4)),
+            ]
+        )
+
+    def _get_shader_code(self) -> str:
+        """Get the WGSL shader code for this pipeline."""
+        return LINE_SHADER_MULTI_COLOURED
+
+    def _get_vertex_buffer_layouts(self):
+        """Get vertex buffer layout configurations for the pipeline."""
+        return [
+            {
+                "array_stride": self._stride,
+                "step_mode": wgpu.VertexStepMode.vertex,
+                "attributes": [
+                    {
+                        "format": NGLToWebGPU.vertex_format(self._data_type),
+                        "offset": 0,
+                        "shader_location": 0,
+                    },
+                ],
+            },
+            {
+                "array_stride": NGLToWebGPU.stride_from_type("Vec3"),
+                "step_mode": wgpu.VertexStepMode.vertex,
+                "attributes": [
+                    {
+                        "format": NGLToWebGPU.vertex_format("Vec3"),
+                        "offset": 0,
+                        "shader_location": 1,
+                    },
+                ],
+            },
+        ]
+
+    def _set_default_uniforms(self) -> None:
+        """Set default values for uniform data."""
+        pass
+
+    def _get_pipeline_label(self) -> str:
+        """Get the label for the pipeline."""
+        return "line_pipeline_multi_coloured"
+
+    def set_data(self, positions=None, colors=None, **kwargs) -> None:
+        """
+        Set the line data for rendering.
+
+        Args:
+            positions: Nx2/Nx3 array of line positions or a pre-existing GPUBuffer.
+            colors: Nx3 array of line colors (RGB) or a pre-existing GPUBuffer.
+        """
+        if positions is not None:
+            if isinstance(positions, wgpu.GPUBuffer):
+                self.vertex_buffer = positions
+                self.num_vertices = positions.size // self._stride
+            else:  # numpy array
+                self.vertex_buffer, buffer_size = self._create_or_update_buffer(
+                    self.vertex_buffer,
+                    positions,
+                    wgpu.BufferUsage.VERTEX | wgpu.BufferUsage.COPY_DST,
+                    "line_pipeline_multi_coloured_position_buffer",
+                )
+                self.num_vertices = buffer_size // self._stride
+
+        if colors is not None:
+            if isinstance(colors, wgpu.GPUBuffer):
+                self.color_buffer = colors
+            else:
+                color_result = self._process_vertex_data(
+                    colors,
+                    None,
+                    padding_size=4,  # Pad to vec4 for alignment
+                    buffer_label="line_pipeline_multi_coloured_colour_buffer",
+                )
+                if isinstance(color_result, wgpu.GPUBuffer):
+                    self.color_buffer = color_result
+                elif color_result:
+                    self.color_buffer = color_result[0]
+                else:
+                    self.color_buffer = None
+
+    def update_uniforms(self, **kwargs) -> None:
+        """
+        Update uniform buffer values.
+
+        Args:
+            **kwargs: Pipeline-specific uniform parameters
+                - mvp: 4x4 projection matrix
+        """
+        if "mvp" in kwargs and kwargs["mvp"] is not None:
+            self.uniform_data["MVP"] = kwargs["mvp"]
+
+        self.device.queue.write_buffer(
+            self.uniform_buffer, 0, self.uniform_data.tobytes()
+        )
+
+    def render(self, render_pass: wgpu.GPURenderPassEncoder, **kwargs) -> None:
+        """
+        Render the lines.
+
+        Args:
+            render_pass: Active render pass encoder
+            **kwargs: Pipeline-specific render parameters
+                - num_vertices: Number of vertices to render (defaults to all)
+        """
+        num_vertices = kwargs.get("num_vertices", None)
+
+        if self.vertex_buffer is None or self.color_buffer is None:
+            return
+
+        count = num_vertices if num_vertices is not None else self.num_vertices
+
+        render_pass.set_pipeline(self.pipeline)
+        if self.bind_group:
+            render_pass.set_bind_group(0, self.bind_group, [], 0, 999999)
+        render_pass.set_vertex_buffer(0, self.vertex_buffer)
+        render_pass.set_vertex_buffer(1, self.color_buffer)
+        render_pass.draw(count)
+
+    def cleanup(self) -> None:
+        """Release resources."""
+        if self.vertex_buffer:
+            self.vertex_buffer.destroy()
+        if self.color_buffer:
+            self.color_buffer.destroy()
+        super().cleanup()
+
+
+class LinePipelineSingleColour(BaseLinePipeline):
+    """
+    A reusable pipeline for rendering lines in WebGPU with single color.
+
+    Features:
+    - Line strips or line segments
+    - Single color for all lines
+    - MVP matrix support
+    - MSAA support
+    """
+
+    def __init__(
+        self,
+        device: wgpu.GPUDevice,
+        data_type: str = "Vec3",
+        texture_format: wgpu.TextureFormat = wgpu.TextureFormat.rgba8unorm,
+        depth_format: wgpu.TextureFormat = wgpu.TextureFormat.depth24plus,
+        msaa_sample_count: int = 4,
+        stride: int = 0,
+        topology: wgpu.PrimitiveTopology = wgpu.PrimitiveTopology.line_list,
+        colour: Tuple[float, float, float] = (1.0, 1.0, 1.0),
+    ):
+        """
+        Initialize line rendering pipeline.
+
+        Args:
+            device: WebGPU device
+            texture_format: Color attachment format
+            depth_format: Depth attachment format
+            msaa_sample_count: Number of MSAA samples
+            stride: The stride of the vertex buffer. If 0, it is inferred from data_type.
+            topology: Primitive topology (line_list or line_strip)
+            colour: RGB color tuple for lines (default white)
+        """
+        # Pipeline-specific buffer tracking
+        self.vertex_buffer: Optional[wgpu.GPUBuffer] = None
+        self.num_vertices: int = 0
+        self._colour = np.array(colour, dtype=np.float32)
+
+        super().__init__(
+            device=device,
+            texture_format=texture_format,
+            depth_format=depth_format,
+            msaa_sample_count=msaa_sample_count,
+            data_type=data_type,
+            stride=stride,
+            topology=topology,
+        )
+
+    def get_dtype(self) -> np.dtype:
+        """Get the data type of the pipeline."""
+        return np.dtype(
+            [
+                ("MVP", "float32", (4, 4)),
+                ("Colour", "float32", 3),
+                ("padding", "float32", 1),
+            ]
+        )
+
+    def _get_shader_code(self) -> str:
+        """Get the WGSL shader code for this pipeline."""
+        return LINE_SHADER_SINGLE_COLOUR
+
+    def _get_vertex_buffer_layouts(self):
+        """Get vertex buffer layout configurations for the pipeline."""
+        return [
+            {
+                "array_stride": self._stride,
+                "step_mode": wgpu.VertexStepMode.vertex,
+                "attributes": [
+                    {
+                        "format": NGLToWebGPU.vertex_format(self._data_type),
+                        "offset": 0,
+                        "shader_location": 0,
+                    },
+                ],
+            },
+        ]
+
+    def _set_default_uniforms(self) -> None:
+        """Set default values for uniform data."""
+        pass
+
+    def _get_pipeline_label(self) -> str:
+        """Get the label for the pipeline."""
+        return "line_pipeline_single_colour"
+
+    def set_data(self, positions=None, colors=None, **kwargs) -> None:
+        """
+        Set the line data for rendering.
+
+        Args:
+            positions: Nx2/Nx3 array of line positions or a pre-existing GPUBuffer.
+            colors: Ignored for single colour pipeline
+        """
+        if positions is not None:
+            if isinstance(positions, wgpu.GPUBuffer):
+                self.vertex_buffer = positions
+                self.num_vertices = positions.size // self._stride
+            else:  # numpy array
+                self.vertex_buffer, buffer_size = self._create_or_update_buffer(
+                    self.vertex_buffer,
+                    positions,
+                    wgpu.BufferUsage.VERTEX | wgpu.BufferUsage.COPY_DST,
+                    "line_pipeline_single_colour_position_buffer",
+                )
+                self.num_vertices = buffer_size // self._stride
+
+    def update_uniforms(self, **kwargs) -> None:
+        """
+        Update uniform buffer values.
+
+        Args:
+            **kwargs: Pipeline-specific uniform parameters
+                - mvp: 4x4 projection matrix
+                - colour: RGB color tuple
+        """
+        if "mvp" in kwargs and kwargs["mvp"] is not None:
+            self.uniform_data["MVP"] = kwargs["mvp"]
+
+        if "colour" in kwargs and kwargs["colour"] is not None:
+            colour = np.array(kwargs["colour"], dtype=np.float32)
+            if colour.shape == (3,):
+                self.uniform_data["Colour"] = colour
+                self._colour = colour
+
+        self.device.queue.write_buffer(
+            self.uniform_buffer, 0, self.uniform_data.tobytes()
+        )
+
+    def set_color(self, colour: Tuple[float, float, float]) -> None:
+        """
+        Set the color for the lines.
+
+        Args:
+            colour: RGB color tuple
+        """
+        colour_array = np.array(colour, dtype=np.float32)
+        if colour_array.shape == (3,):
+            self.uniform_data["Colour"] = colour_array
+            self._colour = colour_array
+            self.device.queue.write_buffer(
+                self.uniform_buffer, 0, self.uniform_data.tobytes()
+            )
+
+    def render(self, render_pass: wgpu.GPURenderPassEncoder, **kwargs) -> None:
+        """
+        Render the lines.
+
+        Args:
+            render_pass: Active render pass encoder
+            **kwargs: Pipeline-specific render parameters
+                - num_vertices: Number of vertices to render (defaults to all)
+        """
+        num_vertices = kwargs.get("num_vertices", None)
+
+        if self.vertex_buffer is None:
+            return
+
+        count = num_vertices if num_vertices is not None else self.num_vertices
+
+        render_pass.set_pipeline(self.pipeline)
+        if self.bind_group:
+            render_pass.set_bind_group(0, self.bind_group, [], 0, 999999)
+        render_pass.set_vertex_buffer(0, self.vertex_buffer)
+        render_pass.draw(count)
+
+    def cleanup(self) -> None:
+        """Release resources."""
+        if self.vertex_buffer:
+            self.vertex_buffer.destroy()
+        super().cleanup()

ncca/ngl/webgpu/pipeline_factory.py

@@ -0,0 +1,190 @@
+"""
+Extensible factory for WebGPU pipelines It will create several default pipelines used in demos
+and allow the user to create custom pipelines.
+Provides abstract base class and factory for creating various pipeline types.
+"""
+
+from enum import Enum
+from typing import Any, Dict, Optional, Type
+
+import numpy as np
+import wgpu
+
+from .base_webgpu_pipeline import BaseWebGPUPipeline
+from .point_pipeline import PointPipelineMultiColour, PointPipelineSingleColour
+from .point_list_pipeline import (
+    PointListPipelineMultiColour,
+    PointListPipelineSingleColour,
+)
+from .point_list_pipeline import (
+    PointListPipelineMultiColour,
+    PointListPipelineSingleColour,
+)
+from .line_pipeline import LinePipelineMultiColour, LinePipelineSingleColour
+from .triangle_pipeline import TrianglePipelineMultiColour, TrianglePipelineSingleColour
+from .instanced_geometry_pipeline import (
+    InstancedGeometryPipelineMultiColour,
+    InstancedGeometryPipelineSingleColour,
+)
+
+
+class PipelineType(Enum):
+    """Enumeration of available pipeline types."""
+
+    MULTI_COLOURED_LINES = "multi_coloured_lines"
+    SINGLE_COLOUR_LINES = "single_colour_lines"
+    MULTI_COLOURED_POINTS = "multi_coloured_points"
+    SINGLE_COLOUR_POINTS = "single_colour_points"
+    MULTI_COLOURED_TRIANGLES = "multi_coloured_triangles"
+    SINGLE_COLOUR_TRIANGLES = "single_colour_triangles"
+    TRIANGLE_LIST_MULTI_COLOURED = "triangle_list_multi_coloured"
+    TRIANGLE_LIST_SINGLE_COLOUR = "triangle_list_single_colour"
+    TRIANGLE_STRIP_MULTI_COLOURED = "triangle_strip_multi_coloured"
+    TRIANGLE_STRIP_SINGLE_COLOUR = "triangle_strip_single_colour"
+    POINT_LIST_MULTI_COLOURED = "point_list_multi_coloured"
+    POINT_LIST_SINGLE_COLOUR = "point_list_single_colour"
+    MULTI_COLOURED_INSTANCED_GEOMETRY = "multi_coloured_instanced_geometry"
+    SINGLE_COLOUR_INSTANCED_GEOMETRY = "single_colour_instanced_geometry"
+
+
+# Backward compatibility alias
+BasePipeline = BaseWebGPUPipeline
+
+
+class _PipelineFactory:
+    """
+    Factory for creating pipeline instances with various configurations.
+    """
+
+    def __init__(self):
+        """Initialize the pipeline factory with default pipeline types."""
+        self._pipeline_registry: Dict[PipelineType, Type[BasePipeline]] = {}
+        self.register_pipeline(
+            PipelineType.MULTI_COLOURED_POINTS, PointPipelineMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.SINGLE_COLOUR_POINTS, PointPipelineSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.MULTI_COLOURED_LINES, LinePipelineMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.SINGLE_COLOUR_LINES, LinePipelineSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.MULTI_COLOURED_TRIANGLES, TrianglePipelineMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.SINGLE_COLOUR_TRIANGLES, TrianglePipelineSingleColour
+        )
+
+        # Create wrapper classes for specific topology types
+        class TriangleListMultiColour(TrianglePipelineMultiColour):
+            def __init__(self, device):
+                super().__init__(device, topology=wgpu.PrimitiveTopology.triangle_list)
+
+        class TriangleListSingleColour(TrianglePipelineSingleColour):
+            def __init__(self, device):
+                super().__init__(device, topology=wgpu.PrimitiveTopology.triangle_list)
+
+        class TriangleStripMultiColour(TrianglePipelineMultiColour):
+            def __init__(self, device):
+                super().__init__(device, topology=wgpu.PrimitiveTopology.triangle_strip)
+
+        class TriangleStripSingleColour(TrianglePipelineSingleColour):
+            def __init__(self, device):
+                super().__init__(device, topology=wgpu.PrimitiveTopology.triangle_strip)
+
+        self.register_pipeline(
+            PipelineType.TRIANGLE_LIST_MULTI_COLOURED, TriangleListMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_LIST_SINGLE_COLOUR, TriangleListSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_STRIP_MULTI_COLOURED, TriangleStripMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_STRIP_SINGLE_COLOUR, TriangleStripSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.SINGLE_COLOUR_TRIANGLES, TrianglePipelineSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_LIST_MULTI_COLOURED,
+            lambda device: TrianglePipelineMultiColour(
+                device, topology=wgpu.PrimitiveTopology.triangle_list
+            ),
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_LIST_SINGLE_COLOUR,
+            lambda device: TrianglePipelineSingleColour(
+                device, topology=wgpu.PrimitiveTopology.triangle_list
+            ),
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_STRIP_MULTI_COLOURED,
+            lambda device: TrianglePipelineMultiColour(
+                device, topology=wgpu.PrimitiveTopology.triangle_strip
+            ),
+        )
+        self.register_pipeline(
+            PipelineType.TRIANGLE_STRIP_SINGLE_COLOUR,
+            lambda device: TrianglePipelineSingleColour(
+                device, topology=wgpu.PrimitiveTopology.triangle_strip
+            ),
+        )
+        self.register_pipeline(
+            PipelineType.POINT_LIST_MULTI_COLOURED, PointListPipelineMultiColour
+        )
+        self.register_pipeline(
+            PipelineType.POINT_LIST_SINGLE_COLOUR, PointListPipelineSingleColour
+        )
+        self.register_pipeline(
+            PipelineType.MULTI_COLOURED_INSTANCED_GEOMETRY,
+            InstancedGeometryPipelineMultiColour,
+        )
+        self.register_pipeline(
+            PipelineType.SINGLE_COLOUR_INSTANCED_GEOMETRY,
+            InstancedGeometryPipelineSingleColour,
+        )
+
+    def register_pipeline(
+        self, pipeline_type: PipelineType, pipeline_class: Type[BaseWebGPUPipeline]
+    ) -> None:
+        """
+        Register a custom pipeline type.
+
+        Args:
+            pipeline_type: Enum identifier for the pipeline
+            pipeline_class: Pipeline class to register
+        """
+        self._pipeline_registry[pipeline_type] = pipeline_class
+
+    def create_pipeline(
+        self, device: wgpu.GPUDevice, pipeline_type: PipelineType, **kwargs
+    ) -> BaseWebGPUPipeline:
+        """
+        Create a pipeline instance.
+
+        Args:
+            device: WebGPU device
+            pipeline_type: Type of pipeline to create
+            **kwargs: Pipeline-specific configuration parameters
+
+        Returns:
+            Configured pipeline instance
+
+        Raises:
+            ValueError: If pipeline type is not registered
+        """
+        if pipeline_type not in self._pipeline_registry:
+            raise ValueError(
+                f"Unknown pipeline type: {pipeline_type}. Available types: {list(self._pipeline_registry.keys())}"
+            )
+
+        pipeline_class = self._pipeline_registry[pipeline_type]
+        return pipeline_class(device, **kwargs)
+
+
+PipelineFactory = _PipelineFactory()