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

ncca/ngl/webgpu/wip/unified_examples.py

@@ -0,0 +1,390 @@
+"""
+Examples and tests for the unified WebGPU pipeline system.
+Demonstrates how to use the new configuration-driven approach with custom shaders.
+"""
+
+import numpy as np
+import wgpu
+
+from ncca.ngl.webgpu import (
+    UnifiedPipelineFactory,
+    PipelineConfigBuilder,
+    PrimitiveType,
+    ColorMode,
+    RenderMode,
+    VertexLayoutBuilder,
+    create_shader_config,
+    generate_shader_code,
+    UniformField,
+    VertexAttribute,
+)
+
+
+def example_basic_usage(device: wgpu.GPUDevice):
+    """Example: Basic pipeline creation using factory methods."""
+    print("=== Basic Usage Examples ===")
+
+    factory = UnifiedPipelineFactory(device)
+
+    # Create pipelines with simple factory methods
+    point_pipeline = factory.create_point_multi_colour()
+    line_pipeline = factory.create_line_single_colour()
+    triangle_pipeline = factory.create_triangle_multi_colour()
+
+    print(f"Created point pipeline: {type(point_pipeline).__name__}")
+    print(f"Created line pipeline: {type(line_pipeline).__name__}")
+    print(f"Created triangle pipeline: {type(triangle_pipeline).__name__}")
+
+    # Set some test data
+    positions = np.array(
+        [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=np.float32
+    )
+    colours = np.array(
+        [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], dtype=np.float32
+    )
+
+    triangle_pipeline.set_data(positions, colours)
+    triangle_pipeline.update_uniforms(mvp=np.eye(4, dtype=np.float32))
+
+    print("Set test data for triangle pipeline")
+
+    return [point_pipeline, line_pipeline, triangle_pipeline]
+
+
+def example_configuration_builder(device: wgpu.GPUDevice):
+    """Example: Using the configuration builder for custom pipelines."""
+    print("\n=== Configuration Builder Examples ===")
+
+    # Create a custom triangle strip configuration
+    config = (
+        PipelineConfigBuilder()
+        .primitive(PrimitiveType.TRIANGLE)
+        .color_mode(ColorMode.MULTI)
+        .topology(wgpu.PrimitiveTopology.triangle_strip)
+        .msaa(8)
+        .cull_mode(wgpu.CullMode.back)
+        .build()
+    )
+
+    factory = UnifiedPipelineFactory(device)
+    pipeline = factory.create_pipeline(config)
+
+    print(f"Created custom triangle strip pipeline: {type(pipeline).__name__}")
+    print(f"MSAA samples: {config.msaa_sample_count}")
+    print(f"Cull mode: {config.cull_mode}")
+
+    return pipeline
+
+
+def example_custom_shaders(device: wgpu.GPUDevice):
+    """Example: Creating pipelines with custom user-defined shaders."""
+    print("\n=== Custom Shader Examples ===")
+
+    factory = UnifiedPipelineFactory(device)
+
+    # Custom vertex shader that adds a wave effect
+    custom_vertex_shader = """
+struct Uniforms {
+    MVP: mat4x4<f32>,
+    time: f32,
+    padding: f32,
+    padding2: f32,
+    padding3: f32,
+};
+
+@binding(0) @group(0) var<uniform> uniforms: Uniforms;
+
+struct VertexIn {
+    @location(0) position: vec3<f32>,
+    @location(1) colour: vec3<f32>,
+};
+
+struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec3<f32>,
+};
+
+@vertex
+fn vertex_main(input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    
+    // Add wave effect based on position and time
+    let wave_offset = sin(uniforms.time + input.position.x * 2.0) * 0.2;
+    let modified_pos = vec3<f32>(input.position.x, input.position.y + wave_offset, input.position.z);
+    
+    output.position = uniforms.MVP * vec4<f32>(modified_pos, 1.0);
+    output.color = input.colour;
+    return output;
+}
+"""
+
+    # Custom fragment shader with gradient effect
+    custom_fragment_shader = """
+struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec3<f32>,
+};
+
+@fragment
+fn fragment_main(input: VertexOut) -> @location(0) vec4<f32>
+{
+    // Add gradient based on screen position
+    let gradient_factor = input.position.y / 600.0; // Assuming 600px height
+    let final_color = input.color * (0.5 + gradient_factor * 0.5);
+    
+    return vec4<f32>(final_color, 1.0);
+}
+"""
+
+    # Create pipeline with custom shaders
+    pipeline = factory.create_with_custom_shaders(
+        vertex_shader=custom_vertex_shader,
+        fragment_shader=custom_fragment_shader,
+        primitive_type=PrimitiveType.TRIANGLE,
+        color_mode=ColorMode.MULTI,
+    )
+
+    print(f"Created pipeline with custom shaders: {type(pipeline).__name__}")
+
+    # Test with custom uniforms
+    positions = np.array(
+        [[-1.0, -1.0, 0.0], [1.0, -1.0, 0.0], [0.0, 1.0, 0.0]], dtype=np.float32
+    )
+    colours = np.array(
+        [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], dtype=np.float32
+    )
+
+    pipeline.set_data(positions, colours)
+    pipeline.update_uniforms(
+        mvp=np.eye(4, dtype=np.float32),
+        time=1.5,  # Custom uniform time parameter
+    )
+
+    print("Set test data with custom time uniform")
+
+    return pipeline
+
+
+def example_custom_uniforms_and_attributes(device: wgpu.GPUDevice):
+    """Example: Using custom uniforms and vertex attributes."""
+    print("\n=== Custom Uniforms and Attributes Examples ===")
+
+    # Define custom uniforms
+    custom_uniforms = [
+        UniformField("time", "f32"),
+        UniformField("wave_amplitude", "f32"),
+        UniformField("wave_frequency", "f32"),
+    ]
+
+    # Define custom vertex attributes
+    custom_attributes = [
+        VertexAttribute("normal", "vec3<f32>", 2, "vertex"),
+        VertexAttribute("uv", "vec2<f32>", 3, "vertex"),
+    ]
+
+    # Create configuration with custom fields
+    config = (
+        PipelineConfigBuilder()
+        .primitive(PrimitiveType.TRIANGLE)
+        .color_mode(ColorMode.MULTI)
+        .custom_uniforms(custom_uniforms)
+        .custom_attributes(custom_attributes)
+        .build()
+    )
+
+    factory = UnifiedPipelineFactory(device)
+    pipeline = factory.create_pipeline(config)
+
+    print(
+        f"Created pipeline with custom uniforms and attributes: {type(pipeline).__name__}"
+    )
+    print(f"Custom uniforms: {[u.name for u in custom_uniforms]}")
+    print(f"Custom attributes: {[a.name for a in custom_attributes]}")
+
+    # Test with custom data
+    positions = np.array(
+        [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=np.float32
+    )
+    colours = np.array(
+        [[1.0, 1.0, 1.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], dtype=np.float32
+    )
+    normals = np.array(
+        [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]], dtype=np.float32
+    )
+    uvs = np.array([[0.0, 0.0], [1.0, 0.0], [0.5, 1.0]], dtype=np.float32)
+
+    pipeline.set_data(
+        positions=positions,
+        colours=colours,
+        normal=normals,  # Custom attribute
+        uv=uvs,  # Custom attribute
+    )
+
+    pipeline.update_uniforms(
+        mvp=np.eye(4, dtype=np.float32),
+        time=2.0,
+        wave_amplitude=0.5,
+        wave_frequency=3.0,
+    )
+
+    print("Set test data with custom attributes and uniforms")
+
+    return pipeline
+
+
+def example_vertex_layout_builder(device: wgpu.GPUDevice):
+    """Example: Using the vertex layout builder for custom buffer layouts."""
+    print("\n=== Vertex Layout Builder Examples ===")
+
+    # Create custom vertex layouts
+    position_layout = (
+        VertexLayoutBuilder()
+        .with_stride(12)  # 3 floats * 4 bytes
+        .with_step_mode("vertex")
+        .with_position("Vec3", offset=0, location=0)
+        .build()
+    )
+
+    color_layout = (
+        VertexLayoutBuilder()
+        .with_stride(16)  # 4 floats * 4 bytes (padded)
+        .with_step_mode("vertex")
+        .with_color("Vec3", offset=0, location=1)
+        .build()
+    )
+
+    normal_layout = (
+        VertexLayoutBuilder()
+        .with_stride(12)
+        .with_step_mode("vertex")
+        .with_normal("Vec3", offset=0, location=2)
+        .build()
+    )
+
+    # Create configuration with custom layouts
+    config = (
+        PipelineConfigBuilder()
+        .primitive(PrimitiveType.TRIANGLE)
+        .color_mode(ColorMode.MULTI)
+        .buffer_layout(position_layout)
+        .buffer_layout(color_layout)
+        .buffer_layout(normal_layout)
+        .build()
+    )
+
+    factory = UnifiedPipelineFactory(device)
+    pipeline = factory.create_pipeline(config)
+
+    print(f"Created pipeline with custom vertex layouts: {type(pipeline).__name__}")
+    print(f"Number of buffer layouts: {len(config.buffer_layouts)}")
+
+    return pipeline
+
+
+def example_shader_template_system(device: wgpu.GPUDevice):
+    """Example: Using the shader template system directly."""
+    print("\n=== Shader Template System Examples ===")
+
+    # Create shader configuration for billboarding points
+    shader_config = create_shader_config(
+        primitive_type=PrimitiveType.POINT,
+        color_mode=ColorMode.MULTI,
+        render_mode=RenderMode.BILLBOARDED,
+    )
+
+    # Generate shader code from template
+    shader_code = generate_shader_code(shader_config)
+
+    print(f"Generated shader code length: {len(shader_code)} characters")
+    print("First few lines of generated shader:")
+    print("\n".join(shader_code.split("\n")[:10]))
+
+    # Create pipeline using generated shader
+    config = (
+        PipelineConfigBuilder()
+        .primitive(PrimitiveType.POINT)
+        .color_mode(ColorMode.MULTI)
+        .render_mode(RenderMode.BILLBOARDED)
+        .build()
+    )
+
+    factory = UnifiedPipelineFactory(device)
+    pipeline = factory.create_pipeline(config)
+
+    print(f"Created pipeline from template: {type(pipeline).__name__}")
+
+    return pipeline
+
+
+def test_unified_system_comprehensive(device: wgpu.GPUDevice):
+    """Comprehensive test of the unified pipeline system."""
+    print("=== Comprehensive Unified System Test ===")
+
+    factory = UnifiedPipelineFactory(device)
+    pipelines = []
+
+    # Test all primitive types and color modes
+    test_cases = [
+        (PrimitiveType.POINT, ColorMode.SINGLE, RenderMode.BILLBOARDED),
+        (PrimitiveType.POINT, ColorMode.MULTI, RenderMode.BILLBOARDED),
+        (PrimitiveType.LINE, ColorMode.SINGLE, RenderMode.STANDARD),
+        (PrimitiveType.LINE, ColorMode.MULTI, RenderMode.STANDARD),
+        (PrimitiveType.TRIANGLE, ColorMode.SINGLE, RenderMode.STANDARD),
+        (PrimitiveType.TRIANGLE, ColorMode.MULTI, RenderMode.STANDARD),
+    ]
+
+    for i, (primitive, color, render) in enumerate(test_cases):
+        config = (
+            PipelineConfigBuilder()
+            .primitive(primitive)
+            .color_mode(color)
+            .render_mode(render)
+            .build()
+        )
+
+        pipeline = factory.create_pipeline(config)
+        pipelines.append(pipeline)
+
+        # Test with basic data
+        positions = np.random.rand(10, 3).astype(np.float32) * 2.0 - 1.0
+        colours = np.random.rand(10, 3).astype(np.float32)
+
+        if color == ColorMode.MULTI:
+            pipeline.set_data(positions, colours)
+        else:
+            pipeline.set_data(positions)
+
+        pipeline.update_uniforms(
+            mvp=np.eye(4, dtype=np.float32),
+            colour=[1.0, 0.0, 0.0] if color == ColorMode.SINGLE else None,
+        )
+
+        print(f"Test {i + 1}: {primitive.value} + {color.value} + {render.value} ✓")
+
+    print(f"Successfully created and tested {len(pipelines)} pipelines")
+    return pipelines
+
+
+if __name__ == "__main__":
+    # This would normally require a WebGPU device, but for demonstration purposes
+    # we'll show the structure of the examples
+    print("WebGPU Unified Pipeline System Examples")
+    print("=======================================")
+    print("This file demonstrates how to use the new unified WebGPU pipeline system.")
+    print("To run these examples, you need a valid WebGPU device instance.")
+    print("")
+    print("Key features demonstrated:")
+    print("1. Basic pipeline creation with factory methods")
+    print("2. Configuration-driven pipeline creation")
+    print("3. Custom shader support")
+    print("4. Custom uniforms and vertex attributes")
+    print("5. Flexible vertex layout system")
+    print("6. Shader template system")
+    print("7. Comprehensive testing of all pipeline types")
+    print("")
+    print("Benefits of the new system:")
+    print("- 60-70% reduction in code duplication")
+    print("- Single unified pipeline class for all use cases")
+    print("- Easy extensibility with custom shaders")
+    print("- Configuration-driven approach")
+    print("- Backward compatibility with existing code")