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

ncca/ngl/webgpu/wip/shader_constants.py

@@ -0,0 +1,328 @@
+"""
+Shared shader constants for WebGPU pipelines to eliminate duplication.
+Contains common shader code patterns and templates.
+"""
+
+# Common uniform structures
+MVP_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+};"""
+
+MVP_VIEW_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    ViewMatrix: mat4x4<f32>,
+};"""
+
+MVP_COLOUR_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    colour: vec3<f32>,
+    padding: f32,
+};"""
+
+MVP_VIEW_SIZE_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    ViewMatrix: mat4x4<f32>,
+    size: f32,
+    padding: u32,
+    padding2: u32,
+    padding3: u32,
+};"""
+
+MVP_VIEW_COLOURSIZE_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    ViewMatrix: mat4x4<f32>,
+    ColourSize: vec4<f32>,
+};"""
+
+MVP_INSTANCED_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    ViewMatrix: mat4x4<f32>,
+    instance_transform: mat4x4<f32>,
+};"""
+
+MVP_INSTANCED_COLOUR_UNIFORM = """struct Uniforms {
+    MVP: mat4x4<f32>,
+    ViewMatrix: mat4x4<f32>,
+    colour: vec3<f32>,
+    padding: f32,
+    instance_transform: mat4x4<f32>,
+};"""
+
+# Common vertex structures
+POSITION_VERTEX = """struct VertexIn {
+    @location(0) position: vec3<f32>,
+};"""
+
+POSITION_COLOUR_VERTEX = """struct VertexIn {
+    @location(0) position: vec3<f32>,
+    @location(1) colour: vec3<f32>,
+};"""
+
+POSITION_INSTANCED_VERTEX = """struct InstanceData {
+    @location(0) position: vec3<f32>,
+    @location(1) colour: vec3<f32>,
+    @location(2) instance_id: f32,
+};
+
+struct GeometryVertex {
+    @location(3) geometry_position: vec3<f32>,
+    @location(4) geometry_normal: vec3<f32>,
+    @location(5) geometry_uv: vec2<f32>,
+};"""
+
+# Common vertex output structures
+BASIC_VERTEX_OUT = """struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+};"""
+
+COLOUR_VERTEX_OUT = """struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) fragColour: vec3<f32>,
+};"""
+
+LIT_VERTEX_OUT = """struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) fragColour: vec3<f32>,
+    @location(1) fragNormal: vec3<f32>,
+    @location(2) fragUV: vec2<f32>,
+    @location(3) worldPos: vec3<f32>,
+};"""
+
+INSTANCED_VERTEX_OUT = """struct VertexOut {
+    @builtin(position) position: vec4<f32>,
+    @location(0) fragColour: vec3<f32>,
+    @location(1) fragNormal: vec3<f32>,
+    @location(2) fragUV: vec2<f32>,
+    @location(3) worldPos: vec3<f32>,
+};"""
+
+# Point rendering constants
+QUAD_OFFSETS = """let quad_offsets = array<vec2<f32>, 4>(
+    vec2<f32>(-1.0, -1.0), // bottom-left
+    vec2<f32>(1.0, -1.0), // bottom-right
+    vec2<f32>(-1.0, 1.0),   // top-left
+    vec2<f32>(1.0, 1.0)    // top-right
+);"""
+
+# Circle clipping for points
+CIRCLE_CLIP = """
+    let center = vec2<f32>(0.5, 0.5);
+    let dist = distance(fragData.uv, center);
+    let radius = 0.5;
+    
+    if (dist > radius) {
+        discard;
+    }
+"""
+
+# Basic lighting
+BASIC_LIGHTING = """
+    // Basic diffuse lighting
+    let light_direction = normalize(vec3<f32>(0.5, 1.0, 0.3));
+    let light_color = vec3<f32>(1.0, 1.0, 1.0);
+    let ambient_intensity = 0.15;
+    let diffuse_intensity = 0.85;
+    
+    // Ambient component
+    let ambient = vec3<f32>(ambient_intensity);
+    
+    // Diffuse component (Lambertian reflection)
+    let normal = normalize(fragData.fragNormal);
+    let n_dot_l = max(dot(normal, light_direction), 0.0);
+    let diffuse = light_color * n_dot_l * diffuse_intensity;
+    
+    // Combine lighting components
+    let final_lighting = ambient + diffuse;
+    
+    // Apply lighting to fragment color
+    let lit_color = fragColor * final_lighting;
+"""
+
+# Billboard generation
+BILLBOARD_LOGIC = """
+    // Extract camera right and up vectors from view matrix
+    let cameraRight = normalize(vec3<f32>(uniforms.ViewMatrix[0][0], uniforms.ViewMatrix[1][0], uniforms.ViewMatrix[2][0]));
+    let cameraUp = normalize(vec3<f32>(uniforms.ViewMatrix[0][1], uniforms.ViewMatrix[1][1], uniforms.ViewMatrix[2][1]));
+    
+    // Calculate billboard offset in world space
+    let offset2D = quad_offsets[vertex_index] * uniforms.size;
+    let offset3D = cameraRight * offset2D.x + cameraUp * offset2D.y;
+    let worldPos = input.position + offset3D;
+"""
+
+# Instanced geometry transforms
+INSTANCED_TRANSFORM_LOGIC = """
+    // Transform geometry vertex by instance transform and position
+    let transformed_vertex = uniforms.instance_transform * vec4<f32>(geom_vertex.geometry_position, 1.0);
+    let world_position = transformed_vertex.xyz + instance_data.position;
+    
+    output.position = uniforms.MVP * vec4<f32>(world_position, 1.0);
+    output.fragColour = instance_data.colour;
+    
+    // Transform normal by instance transform (skip translation)
+    let normal_matrix = mat3x3<f32>(
+        uniforms.instance_transform[0].xyz,
+        uniforms.instance_transform[1].xyz,
+        uniforms.instance_transform[2].xyz
+    );
+    output.fragNormal = normalize(normal_matrix * geom_vertex.geometry_normal);
+    output.fragUV = geom_vertex.geometry_uv;
+    output.worldPos = world_position;
+"""
+
+# Complete shader constants for pipelines
+# Point pipeline shaders
+POINT_SHADER_MULTI_COLOURED = {
+    "vertex": POSITION_COLOUR_VERTEX
+    + MVP_VIEW_SIZE_UNIFORM
+    + QUAD_OFFSETS
+    + COLOUR_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32, input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    
+    // Extract camera right and up vectors from view matrix
+    let cameraRight = normalize(vec3<f32>(uniforms.ViewMatrix[0][0], uniforms.ViewMatrix[1][0], uniforms.ViewMatrix[2][0]));
+    let cameraUp = normalize(vec3<f32>(uniforms.ViewMatrix[0][1], uniforms.ViewMatrix[1][1], uniforms.ViewMatrix[2][1]));
+    
+    // Calculate billboard offset in world space
+    let offset2D = quad_offsets[vertex_index] * uniforms.size;
+    let offset3D = cameraRight * offset2D.x + cameraUp * offset2D.y;
+    let worldPos = input.position + offset3D;
+    
+    output.position = uniforms.MVP * vec4<f32>(worldPos, 1.0);
+    output.fragColour = input.colour;
+    return output;
+}
+""",
+    "fragment": COLOUR_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(input.fragColour, 1.0);
+}
+""",
+}
+
+POINT_SHADER_SINGLE_COLOUR = {
+    "vertex": POSITION_VERTEX
+    + MVP_VIEW_COLOURSIZE_UNIFORM
+    + QUAD_OFFSETS
+    + COLOUR_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_index: u32, input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    
+    // Extract camera right and up vectors from view matrix
+    let cameraRight = normalize(vec3<f32>(uniforms.ViewMatrix[0][0], uniforms.ViewMatrix[1][0], uniforms.ViewMatrix[2][0]));
+    let cameraUp = normalize(vec3<f32>(uniforms.ViewMatrix[0][1], uniforms.ViewMatrix[1][1], uniforms.ViewMatrix[2][1]));
+    
+    // Calculate billboard offset in world space
+    let offset2D = quad_offsets[vertex_index] * uniforms.ColourSize.w;
+    let offset3D = cameraRight * offset2D.x + cameraUp * offset2D.y;
+    let worldPos = input.position + offset3D;
+    
+    output.position = uniforms.MVP * vec4<f32>(worldPos, 1.0);
+    output.fragColour = uniforms.ColourSize.rgb;
+    return output;
+}
+""",
+    "fragment": COLOUR_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(input.fragColour, 1.0);
+}
+""",
+}
+
+# Line pipeline shaders
+LINE_SHADER_MULTI_COLOURED = {
+    "vertex": POSITION_COLOUR_VERTEX
+    + MVP_VIEW_UNIFORM
+    + COLOUR_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    output.position = uniforms.MVP * vec4<f32>(input.position, 1.0);
+    output.fragColour = input.colour;
+    return output;
+}
+""",
+    "fragment": COLOUR_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(input.fragColour, 1.0);
+}
+""",
+}
+
+LINE_SHADER_SINGLE_COLOUR = {
+    "vertex": POSITION_VERTEX
+    + MVP_COLOUR_UNIFORM
+    + COLOUR_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    output.position = uniforms.MVP * vec4<f32>(input.position, 1.0);
+    output.fragColour = uniforms.colour;
+    return output;
+}
+""",
+    "fragment": COLOUR_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(input.fragColour, 1.0);
+}
+""",
+}
+
+# Triangle pipeline shaders (basic placeholders to fix imports)
+TRIANGLE_SHADER_SINGLE_COLOUR = {
+    "vertex": POSITION_VERTEX
+    + MVP_UNIFORM
+    + BASIC_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    output.position = uniforms.MVP * vec4<f32>(input.position, 1.0);
+    return output;
+}
+""",
+    "fragment": BASIC_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(1.0, 1.0, 1.0, 1.0);
+}
+""",
+}
+
+TRIANGLE_SHADER_MULTI_COLOURED = {
+    "vertex": POSITION_COLOUR_VERTEX
+    + MVP_UNIFORM
+    + COLOUR_VERTEX_OUT
+    + """
+@vertex
+fn vs_main(input: VertexIn) -> VertexOut {
+    var output: VertexOut;
+    output.position = uniforms.MVP * vec4<f32>(input.position, 1.0);
+    output.fragColour = input.colour;
+    return output;
+}
+""",
+    "fragment": COLOUR_VERTEX_OUT
+    + """
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+    return vec4<f32>(input.fragColour, 1.0);
+}
+""",
+}