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

ncca/ngl/webgpu/wip/pipeline_config.py

@@ -0,0 +1,463 @@
+"""
+Configuration objects for WebGPU pipeline definitions.
+Provides dataclasses and builders for flexible pipeline configuration.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import wgpu
+
+from .shader_templates import (
+    ColorMode,
+    PrimitiveType,
+    RenderMode,
+    ShaderConfig,
+    UniformField,
+    VertexAttribute,
+    create_shader_config,
+)
+
+
+class TopologyType(Enum):
+    """WebGPU primitive topology types."""
+
+    POINT_LIST = "point_list"
+    LINE_LIST = "line_list"
+    LINE_STRIP = "line_strip"
+    TRIANGLE_LIST = "triangle_list"
+    TRIANGLE_STRIP = "triangle_strip"
+
+
+@dataclass
+class BufferLayout:
+    """Configuration for a vertex buffer layout."""
+
+    stride: int
+    step_mode: str = "vertex"
+    attributes: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class PipelineConfig:
+    """Complete configuration for a WebGPU pipeline."""
+
+    # Core configuration
+    primitive_type: PrimitiveType
+    color_mode: ColorMode
+    topology: wgpu.PrimitiveTopology
+
+    # Rendering options
+    render_mode: RenderMode = RenderMode.STANDARD
+    texture_format: wgpu.TextureFormat = wgpu.TextureFormat.rgba8unorm
+    depth_format: wgpu.TextureFormat = wgpu.TextureFormat.depth24plus
+    msaa_sample_count: int = 4
+
+    # Vertex data configuration
+    data_type: str = "Vec3"
+    stride: int = 0
+
+    # Custom shader support
+    custom_vertex_shader: Optional[str] = None
+    custom_fragment_shader: Optional[str] = None
+
+    # Extended configuration
+    custom_uniforms: Optional[List[UniformField]] = None
+    custom_attributes: Optional[List[VertexAttribute]] = None
+    buffer_layouts: Optional[List[BufferLayout]] = None
+
+    # Pipeline options
+    cull_mode: wgpu.CullMode = wgpu.CullMode.none
+    front_face: wgpu.FrontFace = wgpu.FrontFace.ccw
+
+    def to_shader_config(self) -> ShaderConfig:
+        """Convert to shader configuration."""
+        return create_shader_config(
+            primitive_type=self.primitive_type,
+            color_mode=self.color_mode,
+            render_mode=self.render_mode,
+            custom_vertex_shader=self.custom_vertex_shader,
+            custom_fragment_shader=self.custom_fragment_shader,
+            custom_uniforms=self.custom_uniforms,
+            custom_attributes=self.custom_attributes,
+        )
+
+
+@dataclass
+class BufferConfig:
+    """Configuration for buffer management."""
+
+    name: str
+    data: Optional[Union[np.ndarray, wgpu.GPUBuffer]] = None
+    usage: Optional[wgpu.BufferUsage] = None
+    buffer_label: Optional[str] = None
+    default_value: Optional[np.ndarray] = None
+    padding_size: Optional[int] = None
+
+
+@dataclass
+class UniformConfig:
+    """Configuration for uniform buffer management."""
+
+    name: str
+    data_type: str
+    value: Optional[Union[float, np.ndarray]] = None
+    array_size: Optional[int] = None
+
+
+class PipelineConfigBuilder:
+    """Builder for creating pipeline configurations."""
+
+    def __init__(self):
+        """Initialize builder with default values."""
+        self._config = PipelineConfig(
+            primitive_type=PrimitiveType.TRIANGLE,
+            color_mode=ColorMode.MULTI,
+            topology=wgpu.PrimitiveTopology.triangle_list,
+        )
+        self._buffer_layouts: List[BufferLayout] = []
+        self._uniforms: List[UniformConfig] = []
+
+    def primitive(self, primitive_type: PrimitiveType) -> "PipelineConfigBuilder":
+        """Set primitive type."""
+        self._config.primitive_type = primitive_type
+        return self
+
+    def color_mode(self, color_mode: ColorMode) -> "PipelineConfigBuilder":
+        """Set color mode."""
+        self._config.color_mode = color_mode
+        return self
+
+    def topology(self, topology: wgpu.PrimitiveTopology) -> "PipelineConfigBuilder":
+        """Set primitive topology."""
+        self._config.topology = topology
+        return self
+
+    def render_mode(self, render_mode: RenderMode) -> "PipelineConfigBuilder":
+        """Set render mode."""
+        self._config.render_mode = render_mode
+        return self
+
+    def texture_format(self, format: wgpu.TextureFormat) -> "PipelineConfigBuilder":
+        """Set texture format."""
+        self._config.texture_format = format
+        return self
+
+    def depth_format(self, format: wgpu.TextureFormat) -> "PipelineConfigBuilder":
+        """Set depth format."""
+        self._config.depth_format = format
+        return self
+
+    def msaa(self, samples: int) -> "PipelineConfigBuilder":
+        """Set MSAA sample count."""
+        self._config.msaa_sample_count = samples
+        return self
+
+    def data_type(self, data_type: str) -> "PipelineConfigBuilder":
+        """Set vertex data type."""
+        self._config.data_type = data_type
+        return self
+
+    def stride(self, stride: int) -> "PipelineConfigBuilder":
+        """Set vertex buffer stride."""
+        self._config.stride = stride
+        return self
+
+    def custom_shaders(
+        self,
+        vertex_shader: Optional[str] = None,
+        fragment_shader: Optional[str] = None,
+    ) -> "PipelineConfigBuilder":
+        """Set custom shaders."""
+        self._config.custom_vertex_shader = vertex_shader
+        self._config.custom_fragment_shader = fragment_shader
+        return self
+
+    def custom_uniforms(self, uniforms: List[UniformField]) -> "PipelineConfigBuilder":
+        """Set custom uniforms."""
+        self._config.custom_uniforms = uniforms
+        return self
+
+    def custom_attributes(
+        self, attributes: List[VertexAttribute]
+    ) -> "PipelineConfigBuilder":
+        """Set custom vertex attributes."""
+        self._config.custom_attributes = attributes
+        return self
+
+    def buffer_layout(self, layout: BufferLayout) -> "PipelineConfigBuilder":
+        """Add a buffer layout."""
+        self._buffer_layouts.append(layout)
+        return self
+
+    def cull_mode(self, mode: wgpu.CullMode) -> "PipelineConfigBuilder":
+        """Set cull mode."""
+        self._config.cull_mode = mode
+        return self
+
+    def front_face(self, face: wgpu.FrontFace) -> "PipelineConfigBuilder":
+        """Set front face winding."""
+        self._config.front_face = face
+        return self
+
+    def build(self) -> PipelineConfig:
+        """Build the pipeline configuration."""
+        if self._buffer_layouts:
+            self._config.buffer_layouts = self._buffer_layouts
+        return self._config
+
+
+class VertexLayoutBuilder:
+    """Builder for creating vertex buffer layouts."""
+
+    def __init__(self, stride: int = 0, step_mode: str = "vertex"):
+        """Initialize layout builder."""
+        self.stride = stride
+        self.step_mode = step_mode
+        self.attributes: List[Dict[str, Any]] = []
+
+    def with_stride(self, stride: int) -> "VertexLayoutBuilder":
+        """Set stride for the layout."""
+        self.stride = stride
+        return self
+
+    def with_step_mode(self, step_mode: str) -> "VertexLayoutBuilder":
+        """Set step mode for the layout."""
+        self.step_mode = step_mode
+        return self
+
+    def add_attribute(
+        self,
+        format: str,
+        offset: int,
+        shader_location: int,
+    ) -> "VertexLayoutBuilder":
+        """Add an attribute to the layout."""
+        self.attributes.append(
+            {
+                "format": format,
+                "offset": offset,
+                "shader_location": shader_location,
+            }
+        )
+        return self
+
+    def with_position(
+        self,
+        data_type: str = "Vec3",
+        offset: int = 0,
+        location: int = 0,
+    ) -> "VertexLayoutBuilder":
+        """Add position attribute."""
+        from .webgpu_constants import NGLToWebGPU
+
+        self.attributes.append(
+            {
+                "format": NGLToWebGPU.vertex_format(data_type),
+                "offset": offset,
+                "shader_location": location,
+            }
+        )
+        return self
+
+    def with_color(
+        self,
+        data_type: str = "Vec3",
+        offset: int = 0,
+        location: int = 1,
+    ) -> "VertexLayoutBuilder":
+        """Add color attribute."""
+        from .webgpu_constants import NGLToWebGPU
+
+        self.attributes.append(
+            {
+                "format": NGLToWebGPU.vertex_format(data_type),
+                "offset": offset,
+                "shader_location": location,
+            }
+        )
+        return self
+
+    def with_normal(
+        self,
+        data_type: str = "Vec3",
+        offset: int = 0,
+        location: int = 2,
+    ) -> "VertexLayoutBuilder":
+        """Add normal attribute."""
+        from .webgpu_constants import NGLToWebGPU
+
+        self.attributes.append(
+            {
+                "format": NGLToWebGPU.vertex_format(data_type),
+                "offset": offset,
+                "shader_location": location,
+            }
+        )
+        return self
+
+    def with_texcoord(
+        self,
+        data_type: str = "Vec2",
+        offset: int = 0,
+        location: int = 3,
+    ) -> "VertexLayoutBuilder":
+        """Add texture coordinate attribute."""
+        from .webgpu_constants import NGLToWebGPU
+
+        self.attributes.append(
+            {
+                "format": NGLToWebGPU.vertex_format(data_type),
+                "offset": offset,
+                "shader_location": location,
+            }
+        )
+        return self
+
+    def with_custom_attribute(
+        self,
+        data_type: str,
+        offset: int,
+        location: int,
+    ) -> "VertexLayoutBuilder":
+        """Add custom attribute."""
+        from .webgpu_constants import NGLToWebGPU
+
+        self.attributes.append(
+            {
+                "format": NGLToWebGPU.vertex_format(data_type),
+                "offset": offset,
+                "shader_location": location,
+            }
+        )
+        return self
+
+    def build(self) -> BufferLayout:
+        """Build the buffer layout."""
+        return BufferLayout(
+            stride=self.stride,
+            step_mode=self.step_mode,
+            attributes=self.attributes.copy(),
+        )
+
+
+# Predefined configurations for common use cases
+class PredefinedConfigs:
+    """Predefined pipeline configurations."""
+
+    @staticmethod
+    def point_single_colour() -> PipelineConfig:
+        """Single color point pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.POINT)
+            .color_mode(ColorMode.SINGLE)
+            .render_mode(RenderMode.BILLBOARDED)
+            .topology(wgpu.PrimitiveTopology.triangle_strip)
+            .build()
+        )
+
+    @staticmethod
+    def point_multi_colour() -> PipelineConfig:
+        """Multi-color point pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.POINT)
+            .color_mode(ColorMode.MULTI)
+            .render_mode(RenderMode.BILLBOARDED)
+            .topology(wgpu.PrimitiveTopology.triangle_strip)
+            .build()
+        )
+
+    @staticmethod
+    def line_single_colour() -> PipelineConfig:
+        """Single color line pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.LINE)
+            .color_mode(ColorMode.SINGLE)
+            .topology(wgpu.PrimitiveTopology.line_list)
+            .build()
+        )
+
+    @staticmethod
+    def line_multi_colour() -> PipelineConfig:
+        """Multi-color line pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.LINE)
+            .color_mode(ColorMode.MULTI)
+            .topology(wgpu.PrimitiveTopology.line_list)
+            .build()
+        )
+
+    @staticmethod
+    def triangle_single_colour() -> PipelineConfig:
+        """Single color triangle pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.TRIANGLE)
+            .color_mode(ColorMode.SINGLE)
+            .topology(wgpu.PrimitiveTopology.triangle_list)
+            .build()
+        )
+
+    @staticmethod
+    def triangle_multi_colour() -> PipelineConfig:
+        """Multi-color triangle pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.TRIANGLE)
+            .color_mode(ColorMode.MULTI)
+            .topology(wgpu.PrimitiveTopology.triangle_list)
+            .build()
+        )
+
+    @staticmethod
+    def triangle_strip_single_colour() -> PipelineConfig:
+        """Single color triangle strip pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.TRIANGLE)
+            .color_mode(ColorMode.SINGLE)
+            .topology(wgpu.PrimitiveTopology.triangle_strip)
+            .build()
+        )
+
+    @staticmethod
+    def triangle_strip_multi_colour() -> PipelineConfig:
+        """Multi-color triangle strip pipeline configuration."""
+        return (
+            PipelineConfigBuilder()
+            .primitive(PrimitiveType.TRIANGLE)
+            .color_mode(ColorMode.MULTI)
+            .topology(wgpu.PrimitiveTopology.triangle_strip)
+            .build()
+        )
+
+
+def create_pipeline_config(
+    primitive_type: PrimitiveType,
+    color_mode: ColorMode,
+    topology: Optional[wgpu.PrimitiveTopology] = None,
+    **kwargs,
+) -> PipelineConfig:
+    """Create a pipeline configuration with sensible defaults."""
+    if topology is None:
+        # Set default topology based on primitive type
+        if primitive_type == PrimitiveType.POINT:
+            topology = wgpu.PrimitiveTopology.triangle_strip  # For billboarding
+        elif primitive_type == PrimitiveType.LINE:
+            topology = wgpu.PrimitiveTopology.line_list
+        else:  # TRIANGLE
+            topology = wgpu.PrimitiveTopology.triangle_list
+
+    return (
+        PipelineConfigBuilder()
+        .primitive(primitive_type)
+        .color_mode(color_mode)
+        .topology(topology)
+        .build()
+    )