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

ncca/ngl/webgpu/wip/unified_factory.py

@@ -0,0 +1,449 @@
+"""
+Simplified factory for WebGPU pipelines with configuration-driven approach.
+Provides easy creation of unified pipelines with predefined and custom configurations.
+"""
+
+from typing import Dict, Optional, Type
+
+import wgpu
+
+from .base_webgpu_pipeline import BaseWebGPUPipeline
+from .pipeline_config import (
+    PipelineConfig,
+    PipelineConfigBuilder,
+    PredefinedConfigs,
+    PrimitiveType,
+    ColorMode,
+    RenderMode,
+    create_pipeline_config,
+)
+from .unified_pipeline import UnifiedWebGPUPipeline
+from .shader_templates import (
+    ShaderTemplate,
+    PrimitiveType as ShaderPrimitiveType,
+    shader_registry,
+)
+
+
+class UnifiedPipelineFactory:
+    """
+    Simplified factory for creating unified WebGPU pipelines.
+
+    Provides easy methods for creating common pipeline types and supports
+    custom configurations and user-defined shaders.
+    """
+
+    def __init__(self, device: wgpu.GPUDevice):
+        """
+        Initialize factory with WebGPU device.
+
+        Args:
+            device: WebGPU device for pipeline creation
+        """
+        self.device = device
+        self._custom_templates: Dict[str, Type[ShaderTemplate]] = {}
+
+    # Predefined pipeline creation methods
+
+    def create_point_single_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create single color point pipeline with billboarding."""
+        config = PredefinedConfigs.point_single_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_point_multi_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create multi-color point pipeline with billboarding."""
+        config = PredefinedConfigs.point_multi_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_line_single_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create single color line pipeline."""
+        config = PredefinedConfigs.line_single_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_line_multi_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create multi-color line pipeline."""
+        config = PredefinedConfigs.line_multi_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_triangle_single_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create single color triangle pipeline."""
+        config = PredefinedConfigs.triangle_single_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_triangle_multi_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create multi-color triangle pipeline."""
+        config = PredefinedConfigs.triangle_multi_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_triangle_strip_single_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create single color triangle strip pipeline."""
+        config = PredefinedConfigs.triangle_strip_single_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    def create_triangle_strip_multi_colour(self, **kwargs) -> UnifiedWebGPUPipeline:
+        """Create multi-color triangle strip pipeline."""
+        config = PredefinedConfigs.triangle_strip_multi_colour()
+        return self.create_pipeline(config, **kwargs)
+
+    # Flexible configuration methods
+
+    def create_from_builder(
+        self, builder: PipelineConfigBuilder
+    ) -> UnifiedWebGPUPipeline:
+        """Create pipeline from configuration builder."""
+        config = builder.build()
+        return self.create_pipeline(config)
+
+    def create_pipeline(
+        self, config: PipelineConfig, **kwargs
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create pipeline from configuration.
+
+        Args:
+            config: Pipeline configuration
+            **kwargs: Additional configuration overrides
+
+        Returns:
+            Created unified pipeline
+        """
+        # Apply any configuration overrides
+        if kwargs:
+            config = self._apply_config_overrides(config, **kwargs)
+
+        return UnifiedWebGPUPipeline(self.device, config)
+
+    def create_custom(
+        self,
+        primitive_type: PrimitiveType,
+        color_mode: ColorMode,
+        topology: Optional[wgpu.PrimitiveTopology] = None,
+        render_mode: RenderMode = RenderMode.STANDARD,
+        **kwargs,
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create custom pipeline with specified parameters.
+
+        Args:
+            primitive_type: Type of primitive to render
+            color_mode: Color rendering mode
+            topology: WebGPU primitive topology
+            render_mode: Special rendering mode
+            **kwargs: Additional configuration options
+
+        Returns:
+            Created unified pipeline
+        """
+        config = create_pipeline_config(
+            primitive_type=primitive_type,
+            color_mode=color_mode,
+            topology=topology,
+            render_mode=render_mode,
+            **kwargs,
+        )
+
+        return self.create_pipeline(config)
+
+    def create_with_custom_shaders(
+        self,
+        vertex_shader: str,
+        fragment_shader: str,
+        primitive_type: PrimitiveType = PrimitiveType.TRIANGLE,
+        color_mode: ColorMode = ColorMode.MULTI,
+        topology: Optional[wgpu.PrimitiveTopology] = None,
+        **kwargs,
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create pipeline with custom user-defined shaders.
+
+        Args:
+            vertex_shader: Custom WGSL vertex shader code
+            fragment_shader: Custom WGSL fragment shader code
+            primitive_type: Type of primitive to render
+            color_mode: Color rendering mode
+            topology: WebGPU primitive topology
+            **kwargs: Additional configuration options
+
+        Returns:
+            Created unified pipeline with custom shaders
+        """
+        config = create_pipeline_config(
+            primitive_type=primitive_type,
+            color_mode=color_mode,
+            topology=topology,
+            custom_vertex_shader=vertex_shader,
+            custom_fragment_shader=fragment_shader,
+            **kwargs,
+        )
+
+        return self.create_pipeline(config)
+
+    def create_with_vertex_shader(
+        self,
+        vertex_shader: str,
+        primitive_type: PrimitiveType = PrimitiveType.TRIANGLE,
+        color_mode: ColorMode = ColorMode.MULTI,
+        topology: Optional[wgpu.PrimitiveTopology] = None,
+        **kwargs,
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create pipeline with custom vertex shader (uses template fragment shader).
+
+        Args:
+            vertex_shader: Custom WGSL vertex shader code
+            primitive_type: Type of primitive to render
+            color_mode: Color rendering mode
+            topology: WebGPU primitive topology
+            **kwargs: Additional configuration options
+
+        Returns:
+            Created unified pipeline with custom vertex shader
+        """
+        config = create_pipeline_config(
+            primitive_type=primitive_type,
+            color_mode=color_mode,
+            topology=topology,
+            custom_vertex_shader=vertex_shader,
+            **kwargs,
+        )
+
+        return self.create_pipeline(config)
+
+    def create_with_fragment_shader(
+        self,
+        fragment_shader: str,
+        primitive_type: PrimitiveType = PrimitiveType.TRIANGLE,
+        color_mode: ColorMode = ColorMode.MULTI,
+        topology: Optional[wgpu.PrimitiveTopology] = None,
+        **kwargs,
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create pipeline with custom fragment shader (uses template vertex shader).
+
+        Args:
+            fragment_shader: Custom WGSL fragment shader code
+            primitive_type: Type of primitive to render
+            color_mode: Color rendering mode
+            topology: WebGPU primitive topology
+            **kwargs: Additional configuration options
+
+        Returns:
+            Created unified pipeline with custom fragment shader
+        """
+        config = create_pipeline_config(
+            primitive_type=primitive_type,
+            color_mode=color_mode,
+            topology=topology,
+            custom_fragment_shader=fragment_shader,
+            **kwargs,
+        )
+
+        return self.create_pipeline(config)
+
+    # Advanced customization methods
+
+    def register_custom_template(
+        self, name: str, template_class: Type[ShaderTemplate]
+    ) -> None:
+        """
+        Register a custom shader template.
+
+        Args:
+            name: Name for the template
+            template_class: Shader template class
+        """
+        self._custom_templates[name] = template_class
+        # Register with global shader registry
+        shader_registry.register_template(
+            ShaderPrimitiveType(template_class.__name__.lower()), template_class()
+        )
+
+    def create_with_custom_template(
+        self,
+        template_name: str,
+        primitive_type: PrimitiveType,
+        color_mode: ColorMode,
+        **kwargs,
+    ) -> UnifiedWebGPUPipeline:
+        """
+        Create pipeline using custom shader template.
+
+        Args:
+            template_name: Name of registered custom template
+            primitive_type: Type of primitive to render
+            color_mode: Color rendering mode
+            **kwargs: Additional configuration options
+
+        Returns:
+            Created unified pipeline using custom template
+        """
+        if template_name not in self._custom_templates:
+            raise ValueError(f"Custom template '{template_name}' not registered")
+
+        config = create_pipeline_config(
+            primitive_type=primitive_type,
+            color_mode=color_mode,
+            **kwargs,
+        )
+
+        return self.create_pipeline(config)
+
+    # Utility methods
+
+    def _apply_config_overrides(
+        self, config: PipelineConfig, **kwargs
+    ) -> PipelineConfig:
+        """Apply configuration overrides to create new config."""
+        # Create builder from existing config
+        builder = PipelineConfigBuilder()
+
+        # Copy existing settings
+        builder.primitive(config.primitive_type)
+        builder.color_mode(config.color_mode)
+        builder.topology(config.topology)
+        builder.render_mode(config.render_mode)
+        builder.texture_format(config.texture_format)
+        builder.depth_format(config.depth_format)
+        builder.msaa(config.msaa_sample_count)
+        builder.data_type(config.data_type)
+        builder.stride(config.stride)
+        builder.cull_mode(config.cull_mode)
+        builder.front_face(config.front_face)
+
+        # Apply custom configurations
+        if config.custom_vertex_shader:
+            builder.custom_shaders(vertex_shader=config.custom_vertex_shader)
+        if config.custom_fragment_shader:
+            builder.custom_shaders(fragment_shader=config.custom_fragment_shader)
+        if config.custom_uniforms:
+            builder.custom_uniforms(config.custom_uniforms)
+        if config.custom_attributes:
+            builder.custom_attributes(config.custom_attributes)
+        if config.buffer_layouts:
+            for layout in config.buffer_layouts:
+                builder.buffer_layout(layout)
+
+        # Apply overrides
+        for key, value in kwargs.items():
+            if hasattr(builder, key) and callable(getattr(builder, key)):
+                method = getattr(builder, key)
+                if key in ["custom_shaders", "custom_uniforms", "custom_attributes"]:
+                    method(value)
+                else:
+                    method(value)
+
+        return builder.build()
+
+
+# Backward compatibility factory
+class PipelineFactory(UnifiedPipelineFactory):
+    """Backward compatible factory class."""
+
+    def __init__(self, device: wgpu.GPUDevice):
+        """Initialize backward compatible factory."""
+        super().__init__(device)
+
+        # Maintain legacy registry for compatibility
+        self._pipeline_registry = {}
+
+    def register_pipeline(self, pipeline_type, pipeline_class) -> None:
+        """Register pipeline for backward compatibility."""
+        self._pipeline_registry[pipeline_type] = pipeline_class
+
+    def create_legacy_pipeline(self, pipeline_type, **kwargs) -> BaseWebGPUPipeline:
+        """Create pipeline using legacy registry."""
+        if pipeline_type not in self._pipeline_registry:
+            raise ValueError(f"Unknown pipeline type: {pipeline_type}")
+
+        pipeline_class = self._pipeline_registry[pipeline_type]
+        return pipeline_class(self.device, **kwargs)
+
+
+# Global factory instance
+_global_factory: Optional[UnifiedPipelineFactory] = None
+
+
+def get_factory(device: Optional[wgpu.GPUDevice] = None) -> UnifiedPipelineFactory:
+    """Get or create global factory instance."""
+    global _global_factory
+
+    if _global_factory is None:
+        if device is None:
+            raise ValueError("Device must be provided for first factory creation")
+        _global_factory = UnifiedPipelineFactory(device)
+
+    return _global_factory
+
+
+# Convenience functions for quick pipeline creation
+def create_point_pipeline(
+    device: wgpu.GPUDevice,
+    multi_colour: bool = True,
+    **kwargs,
+) -> UnifiedWebGPUPipeline:
+    """Quick creation of point pipeline."""
+    factory = UnifiedPipelineFactory(device)
+    if multi_colour:
+        return factory.create_point_multi_colour(**kwargs)
+    else:
+        return factory.create_point_single_colour(**kwargs)
+
+
+def create_line_pipeline(
+    device: wgpu.GPUDevice,
+    multi_colour: bool = True,
+    **kwargs,
+) -> UnifiedWebGPUPipeline:
+    """Quick creation of line pipeline."""
+    factory = UnifiedPipelineFactory(device)
+    if multi_colour:
+        return factory.create_line_multi_colour(**kwargs)
+    else:
+        return factory.create_line_single_colour(**kwargs)
+
+
+def create_triangle_pipeline(
+    device: wgpu.GPUDevice,
+    multi_colour: bool = True,
+    triangle_strip: bool = False,
+    **kwargs,
+) -> UnifiedWebGPUPipeline:
+    """Quick creation of triangle pipeline."""
+    factory = UnifiedPipelineFactory(device)
+
+    if triangle_strip:
+        if multi_colour:
+            return factory.create_triangle_strip_multi_colour(**kwargs)
+        else:
+            return factory.create_triangle_strip_single_colour(**kwargs)
+    else:
+        if multi_colour:
+            return factory.create_triangle_multi_colour(**kwargs)
+        else:
+            return factory.create_triangle_single_colour(**kwargs)
+
+
+def create_instanced_geometry_pipeline(
+    device: wgpu.GPUDevice,
+    multi_colour: bool = True,
+    **kwargs,
+) -> UnifiedWebGPUPipeline:
+    """Quick creation of instanced geometry pipeline."""
+    from .pipeline_config import PrimitiveType, ColorMode, RenderMode
+
+    factory = UnifiedPipelineFactory(device)
+
+    if multi_colour:
+        return factory.create_custom(
+            primitive_type=PrimitiveType.TRIANGLE,
+            color_mode=ColorMode.MULTI,
+            render_mode=RenderMode.INSTANCED,
+            **kwargs,
+        )
+    else:
+        return factory.create_custom(
+            primitive_type=PrimitiveType.TRIANGLE,
+            color_mode=ColorMode.SINGLE,
+            render_mode=RenderMode.INSTANCED,
+            **kwargs,
+        )