ncca-ngl 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

ncca/ngl/webgpu/wip/unified_pipeline.py

@@ -0,0 +1,469 @@
+"""
+Unified WebGPU pipeline with user-defined shader support.
+Provides a single, configurable pipeline class that can handle all rendering scenarios.
+"""
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import wgpu
+
+from .base_webgpu_pipeline import BaseWebGPUPipeline
+from .buffer_manager import UnifiedResourceManager
+from .pipeline_config import (
+    BufferLayout,
+    PipelineConfig,
+    VertexLayoutBuilder,
+)
+from .shader_templates import generate_shader_code
+from .webgpu_constants import NGLToWebGPU
+
+
+class UnifiedWebGPUPipeline(BaseWebGPUPipeline):
+    """
+    Unified WebGPU pipeline that supports all primitive types, color modes, and custom shaders.
+
+    Features:
+    - Configurable primitive types (points, lines, triangles)
+    - Single and multi-color rendering modes
+    - User-defined shader support
+    - Billboarding for points
+    - Flexible vertex layouts
+    - MSAA support
+    - Depth testing
+    - Resource management
+    """
+
+    def __init__(self, device: wgpu.GPUDevice, config: PipelineConfig):
+        """
+        Initialize unified pipeline with configuration.
+
+        Args:
+            device: WebGPU device
+            config: Pipeline configuration
+        """
+        self.config = config
+
+        # Calculate stride if not provided
+        if config.stride == 0:
+            stride = NGLToWebGPU.stride_from_type(config.data_type)
+        else:
+            stride = config.stride
+
+        # Initialize resource manager
+        self.resources = UnifiedResourceManager(device)
+
+        # Track vertex data
+        self._vertex_buffers: Dict[str, wgpu.GPUBuffer] = {}
+        self._vertex_counts: Dict[str, int] = {}
+        self._num_vertices: int = 0
+
+        # Initialize base pipeline
+        super().__init__(
+            device=device,
+            texture_format=config.texture_format,
+            depth_format=config.depth_format,
+            msaa_sample_count=config.msaa_sample_count,
+            data_type=config.data_type,
+            stride=stride,
+        )
+
+    def _get_shader_code(self) -> str:
+        """Get shader code from configuration."""
+        if self.config.custom_vertex_shader or self.config.custom_fragment_shader:
+            # Use custom shaders
+            shader_config = self.config.to_shader_config()
+            shader_code = generate_shader_code(shader_config)
+        else:
+            # Use template-based shader generation
+            shader_config = self.config.to_shader_config()
+            shader_code = generate_shader_code(shader_config)
+
+        # Debug: Print shader code for triangles
+        if self.config.primitive_type.value == "triangle":
+            print(f"Generated triangle shader ({self.config.color_mode.value}):")
+            print("=" * 50)
+            print(shader_code)
+            print("=" * 50)
+
+        return shader_code
+
+    def _get_vertex_buffer_layouts(self) -> List[Dict[str, Any]]:
+        """Get vertex buffer layouts from configuration."""
+        if self.config.buffer_layouts:
+            # Use custom buffer layouts
+            return [
+                {
+                    "array_stride": layout.stride,
+                    "step_mode": layout.step_mode,
+                    "attributes": layout.attributes,
+                }
+                for layout in self.config.buffer_layouts
+            ]
+        else:
+            # Generate default layouts based on configuration
+            return self._generate_default_vertex_layouts()
+
+    def _generate_default_vertex_layouts(self) -> List[Dict[str, Any]]:
+        """Generate default vertex buffer layouts based on configuration."""
+        layouts = []
+
+        # Position buffer layout
+        position_layout = (
+            VertexLayoutBuilder(
+                stride=self._stride,
+                step_mode="instance",
+            )
+            .with_position(self.config.data_type, offset=0, location=0)
+            .build()
+        )
+
+        layouts.append(
+            {
+                "array_stride": position_layout.stride,
+                "step_mode": position_layout.step_mode,
+                "attributes": position_layout.attributes,
+            }
+        )
+
+        # Color buffer layout for multi-color mode
+        if self.config.color_mode.value == "multi":
+            color_layout = (
+                VertexLayoutBuilder(
+                    stride=NGLToWebGPU.stride_from_type("Vec3"),
+                    step_mode="instance",
+                )
+                .with_color("Vec3", offset=0, location=1)
+                .build()
+            )
+
+            layouts.append(
+                {
+                    "array_stride": color_layout.stride,
+                    "step_mode": color_layout.step_mode,
+                    "attributes": color_layout.attributes,
+                }
+            )
+
+        # Add custom attribute layouts
+        if self.config.custom_attributes:
+            for i, attr in enumerate(self.config.custom_attributes):
+                # Start layout after position and potential color buffer
+                layout_index = len(layouts)
+                custom_layout = (
+                    VertexLayoutBuilder(
+                        stride=NGLToWebGPU.stride_from_type(attr.data_type),
+                        step_mode=attr.step_mode,
+                    )
+                    .with_custom_attribute(
+                        attr.data_type,
+                        offset=0,
+                        location=attr.location,
+                    )
+                    .build()
+                )
+
+                layouts.append(
+                    {
+                        "array_stride": custom_layout.stride,
+                        "step_mode": custom_layout.step_mode,
+                        "attributes": custom_layout.attributes,
+                    }
+                )
+
+        return layouts
+
+    def _get_primitive_topology(self) -> wgpu.PrimitiveTopology:
+        """Get primitive topology from configuration."""
+        return self.config.topology
+
+    def _set_default_uniforms(self) -> None:
+        """Set default uniform values based on configuration."""
+        shader_config = self.config.to_shader_config()
+
+        # Set default MVP matrix
+        self.uniform_data["MVP"] = np.eye(4, dtype=np.float32)
+
+        # Set defaults based on primitive type and color mode
+        if self.config.primitive_type.value == "point":
+            if self.config.render_mode.value == "billboarded":
+                # View matrix for billboarding
+                self.uniform_data["ViewMatrix"] = np.eye(4, dtype=np.float32)
+
+            if self.config.color_mode.value == "single":
+                # Default white color and size
+                self.uniform_data["ColourSize"] = np.array(
+                    [1.0, 1.0, 1.0, 1.0], dtype=np.float32
+                )
+            else:
+                # Default size for multi-color
+                self.uniform_data["size"] = 1.0
+
+        elif self.config.color_mode.value == "single":
+            # Default white color for non-point primitives
+            self.uniform_data["colour"] = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+
+    def _get_pipeline_label(self) -> str:
+        """Get pipeline label based on configuration."""
+        return (
+            f"unified_pipeline_{self.config.primitive_type.value}_"
+            f"{self.config.color_mode.value}_{self.config.render_mode.value}"
+        )
+
+    def _create_pipeline(self) -> None:
+        """Create pipeline with custom depth stencil and rasterization state."""
+        # Create shader module
+        shader_code = self._get_shader_code()
+        shader_module = self.device.create_shader_module(code=shader_code)
+
+        # Get vertex buffer layouts
+        vertex_layouts = self._get_vertex_buffer_layouts()
+
+        # Create render pipeline
+        self.pipeline = self.device.create_render_pipeline(
+            label=self._get_pipeline_label(),
+            layout="auto",
+            vertex={
+                "module": shader_module,
+                "entry_point": "vertex_main",
+                "buffers": vertex_layouts,
+            },
+            fragment={
+                "module": shader_module,
+                "entry_point": "fragment_main",
+                "targets": [{"format": self.config.texture_format}],
+            },
+            primitive={
+                "topology": self.config.topology,
+                "cull_mode": self.config.cull_mode,
+                "front_face": self.config.front_face,
+            },
+            depth_stencil={
+                "format": self.config.depth_format,
+                "depth_write_enabled": True,
+                "depth_compare": wgpu.CompareFunction.less,
+            },
+            multisample={"count": self.config.msaa_sample_count},
+        )
+
+        # Initialize uniform manager
+        bind_group_layout = self.pipeline.get_bind_group_layout(0)
+        self.resources.uniform_manager.initialize(
+            self.get_dtype(),
+            bind_group_layout,
+        )
+
+        # Store reference to uniform buffer and bind group
+        self.uniform_buffer = self.resources.uniform_manager.get_uniform_buffer()
+        self.bind_group = self.resources.uniform_manager.get_bind_group()
+
+    def get_dtype(self) -> np.dtype:
+        """Get uniform buffer data type based on configuration."""
+        fields = [("MVP", "float32", (4, 4))]
+
+        # Add fields based on configuration
+        if self.config.primitive_type.value == "point":
+            if self.config.render_mode.value == "billboarded":
+                fields.append(("ViewMatrix", "float32", (4, 4)))
+
+            if self.config.color_mode.value == "single":
+                fields.append(("ColourSize", "float32", 4))
+            else:
+                fields.append(("size", "float32"))
+                fields.extend([(f"padding{i}", "uint32") for i in range(3)])
+
+        else:  # Line or Triangle
+            if self.config.color_mode.value == "single":
+                fields.extend(
+                    [
+                        ("colour", "float32", 3),
+                        ("padding", "float32"),
+                    ]
+                )
+            else:
+                fields.extend([(f"padding{i}", "float32") for i in range(4)])
+
+        # Add custom uniform fields
+        if self.config.custom_uniforms:
+            for uniform in self.config.custom_uniforms:
+                if uniform.array_size:
+                    fields.append((uniform.name, uniform.data_type, uniform.array_size))
+                else:
+                    fields.append((uniform.name, uniform.data_type))
+
+        return np.dtype(fields)
+
+    def set_data(
+        self,
+        positions: Union[np.ndarray, wgpu.GPUBuffer],
+        colours: Optional[Union[np.ndarray, wgpu.GPUBuffer]] = None,
+        **kwargs,
+    ) -> None:
+        """
+        Set vertex data for rendering.
+
+        Args:
+            positions: Vertex positions (numpy array or GPU buffer)
+            colours: Vertex colors for multi-color mode (numpy array or GPU buffer)
+            **kwargs: Additional vertex data based on custom attributes
+        """
+        # Process positions
+        if isinstance(positions, wgpu.GPUBuffer):
+            self._vertex_buffers["position"] = positions
+            self._num_vertices = positions.size // self._stride
+        else:
+            self._num_vertices = len(positions)
+            self._vertex_buffers["position"] = (
+                self.resources.buffer_manager.update_buffer(
+                    "position",
+                    positions,
+                    wgpu.BufferUsage.VERTEX | wgpu.BufferUsage.COPY_DST,
+                    f"{self._get_pipeline_label()}_position_buffer",
+                )
+            )
+
+        # Process colors for multi-color mode
+        if self.config.color_mode.value == "multi":
+            if colours is None:
+                # Create default white colors
+                default_colours = np.ones((self._num_vertices, 3), dtype=np.float32)
+                self._vertex_buffers["colour"] = (
+                    self.resources.buffer_manager.process_vertex_data(
+                        "colour",
+                        None,
+                        default_colours,
+                        padding_size=4,  # Pad to vec4 for alignment
+                        buffer_label=f"{self._get_pipeline_label()}_colour_buffer",
+                    )
+                )
+            else:
+                self._vertex_buffers["colour"] = (
+                    self.resources.buffer_manager.process_vertex_data(
+                        "colour",
+                        colours,
+                        None,
+                        padding_size=4,
+                        buffer_label=f"{self._get_pipeline_label()}_colour_buffer",
+                    )
+                )
+
+        # Process custom attributes
+        if self.config.custom_attributes:
+            for attr in self.config.custom_attributes:
+                attr_name = attr.name
+                attr_data = kwargs.get(attr_name)
+                if attr_data is not None:
+                    self._vertex_buffers[attr_name] = (
+                        self.resources.buffer_manager.process_vertex_data(
+                            attr_name,
+                            attr_data,
+                            None,
+                            buffer_label=f"{self._get_pipeline_label()}_{attr_name}_buffer",
+                        )
+                    )
+
+    def update_uniforms(self, **kwargs) -> None:
+        """
+        Update uniform buffer values.
+
+        Args:
+            **kwargs: Uniform parameters
+                - mvp: 4x4 model view projection matrix
+                - view_matrix: 4x4 view matrix (for billboarding)
+                - colour: 3-element RGB color (single color mode)
+                - point_size: Point size (for points)
+                - Custom uniforms based on configuration
+        """
+        uniforms = {}
+
+        # Map common parameter names to uniform field names
+        if "mvp" in kwargs:
+            uniforms["MVP"] = kwargs["mvp"]
+
+        if "view_matrix" in kwargs:
+            uniforms["ViewMatrix"] = kwargs["view_matrix"]
+
+        if "colour" in kwargs and self.config.color_mode.value == "single":
+            if self.config.primitive_type.value == "point":
+                uniforms["ColourSize"] = self.uniform_data["ColourSize"].copy()
+                uniforms["ColourSize"][:3] = kwargs["colour"]
+            else:
+                uniforms["colour"] = kwargs["colour"]
+
+        if "point_size" in kwargs and self.config.primitive_type.value == "point":
+            if self.config.color_mode.value == "single":
+                uniforms["ColourSize"] = self.uniform_data["ColourSize"].copy()
+                uniforms["ColourSize"][3] = kwargs["point_size"]
+            else:
+                uniforms["size"] = kwargs["point_size"]
+
+        # Add custom uniforms
+        if self.config.custom_uniforms:
+            for uniform in self.config.custom_uniforms:
+                if uniform.name in kwargs:
+                    uniforms[uniform.name] = kwargs[uniform.name]
+
+        # Update uniform buffer
+        if uniforms:
+            self.resources.uniform_manager.update_uniforms(uniforms)
+            # Update base class reference
+            self.uniform_data = self.resources.uniform_manager.get_uniform_data()
+
+    def render(
+        self,
+        render_pass: wgpu.GPURenderPassEncoder,
+        num_vertices: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        """
+        Render using this pipeline.
+
+        Args:
+            render_pass: Active render pass encoder
+            num_vertices: Number of vertices to render (defaults to all)
+            **kwargs: Additional render parameters
+        """
+        if not self._vertex_buffers.get("position"):
+            return
+
+        # Determine vertex count
+        count = num_vertices if num_vertices is not None else self._num_vertices
+
+        # Set pipeline and bind group
+        render_pass.set_pipeline(self.pipeline)
+        if self.bind_group:
+            render_pass.set_bind_group(0, self.bind_group, [], 0, 999999)
+
+        # Set vertex buffers
+        slot = 0
+        for buffer_name in ["position", "colour"]:
+            if buffer_name in self._vertex_buffers:
+                render_pass.set_vertex_buffer(slot, self._vertex_buffers[buffer_name])
+                slot += 1
+
+        # Set custom attribute buffers
+        if self.config.custom_attributes:
+            for attr in self.config.custom_attributes:
+                if attr.name in self._vertex_buffers:
+                    render_pass.set_vertex_buffer(slot, self._vertex_buffers[attr.name])
+                    slot += 1
+
+        # Determine vertex count for different primitives
+        if (
+            self.config.primitive_type.value == "point"
+            and self.config.render_mode.value == "billboarded"
+        ):
+            # Points are rendered as 4 vertices (quad) per point
+            vertex_count = 4
+            instance_count = count
+        else:
+            vertex_count = count
+            instance_count = 1
+
+        # Issue draw call
+        render_pass.draw(vertex_count, instance_count)
+
+    def cleanup(self) -> None:
+        """Release pipeline resources."""
+        self.resources.cleanup()
+        super().cleanup()

ncca/ngl/widgets/__init__.py

@@ -1,4 +1,12 @@
-__version__ = "0.1.0"
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("ncca-ngl")  # pragma: no cover
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"
+
+__author__ = "Jon Macey jmacey@bournemouth.ac.uk"
+__license__ = "MIT"
 
 
 from .lookatwidget import LookAtWidget
@@ -9,4 +17,12 @@ from .vec2widget import Vec2Widget
 from .vec3widget import Vec3Widget
 from .vec4widget import Vec4Widget
 
-__all__ = ["Vec2Widget", "Vec3Widget", "Vec4Widget", "TransformWidget", "LookAtWidget", "RGBColourWidget"]
+__all__ = [
+    "Vec2Widget",
+    "Vec3Widget",
+    "Vec4Widget",
+    "TransformWidget",
+    "LookAtWidget",
+    "RGBColourWidget",
+    "RGBAColourWidget",
+]

ncca/ngl/widgets/__main__.py

@@ -11,13 +11,14 @@ from ncca.ngl.widgets import (
     Vec2Widget,
     Vec3Widget,
     Vec4Widget,
+    __version__,
 )
 
 
 class SimpleDialog(QDialog):
     def __init__(self, parent=None):
         super(SimpleDialog, self).__init__(parent)
-        self.setWindowTitle("PyNGL ncca.widgets library ")
+        self.setWindowTitle(f"PyNGL ncca.widgets library {__version__}")
         self.setMinimumWidth(200)
         layout = QGridLayout()
 

ncca/ngl/widgets/lookatwidget.py

@@ -53,6 +53,7 @@ class LookAtWidget(QFrame):
         content_layout.addWidget(self._up)
         main_layout.addWidget(self._toggle_button)
         main_layout.addWidget(self._content_widget)
+        self._update_matrix()
 
     def set_eye(self, eye):
         self._eye.set_value(eye)
@@ -68,7 +69,7 @@ class LookAtWidget(QFrame):
         self._toggle_button.setText(name)
 
     def get_name(self):
-        return self._name.text()
+        return self._name
 
     def get_eye(self):
         return self._eye.value

ncca/ngl/widgets/mat4widget.py

@@ -1,7 +1,7 @@
 from PySide6.QtCore import Property, QSignalBlocker, Signal
 from PySide6.QtWidgets import QDoubleSpinBox, QFrame, QHBoxLayout, QLabel, QWidget
 
-from ncca.ngl import Mat4 
+from ncca.ngl import Mat4
 
 
-class Mat4ViewWidget(QFrame):
+class Mat4ViewWidget(QFrame): ...

ncca/ngl/widgets/vec2widget.py

@@ -78,7 +78,7 @@ class Vec2Widget(QFrame):
         Args:
             value: The new value of the widget.
         """
-        with QSignalBlocker(self.x_spinbox), QSignalBlocker(self.y_spinbox), QSignalBlocker(self.z_spinbox):
+        with QSignalBlocker(self.x_spinbox), QSignalBlocker(self.y_spinbox):
             self.x_spinbox.setValue(value.x)
             self.y_spinbox.setValue(value.y)
         self._value = value

ncca/ngl/widgets/vec3widget.py

@@ -22,6 +22,7 @@ class Vec3Widget(QFrame):
         super().__init__(parent)
         self.setFrameShape(QFrame.Shape.StyledPanel)
         self._value = value
+
         self._name = name
         layout = QHBoxLayout()
 

{ncca_ngl-0.3.4.dist-info → ncca_ngl-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ncca-ngl
-Version: 0.3.4
+Version: 0.5.0
 Summary: A Python version of the NGL graphics library.
 Author: Jon Macey
 Author-email: Jon Macey <jmacey@bournemouth.ac.uk>
@@ -17,6 +17,7 @@ Requires-Dist: pillow
 Requires-Dist: glfw>=2.9.0
 Requires-Dist: freetype-py>=2.5.1
 Requires-Dist: pyside6>=6.9.2
-Requires-Python: >=3.13
+Requires-Dist: wgpu>=0.29.0
+Requires-Python: >=3.11
 Project-URL: Homepage, https://github.com/NCCA/PyNGL
 Project-URL: Issues, https://github.com/NCCA/PyNGL/issues