@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/core/pass/GBuffer_pass.js

@@ -0,0 +1,72 @@
+export let GBuffer_pass = `
+    #include "Common_vert"
+    #include "FragmentVarying"
+    #include "GlobalUniform"
+
+    struct FragmentOutput {
+        @location(auto) o_Position: vec4<f32>,
+        @location(auto) o_Normal: vec4<f32>,
+        @location(auto) o_Color: vec4<f32>
+    };
+
+    struct MaterialUniform {
+        baseColor: vec4<f32>,
+        emissiveColor: vec4<f32>,
+        emissiveIntensity: f32,
+        normalScale: f32,
+        alphaCutoff: f32
+    }
+
+    @group(2) @binding(0)
+    var<uniform> materialUniform: MaterialUniform;
+
+    @group(1) @binding(auto)
+    var baseMapSampler: sampler;
+    @group(1) @binding(auto)
+    var baseMap: texture_2d<f32>;
+
+    @group(1) @binding(auto)
+    var normalMapSampler: sampler;
+    @group(1) @binding(auto)
+    var normalMap: texture_2d<f32>;
+
+    @group(1) @binding(auto)
+    var emissiveMapSampler: sampler;
+    @group(1) @binding(auto)
+    var emissiveMap: texture_2d<f32>;
+
+    fn vert(inputData:VertexAttributes) -> VertexOutput {
+        ORI_Vert(inputData) ;
+        return ORI_VertexOut ;
+    }
+
+    var<private> ORI_FragmentOutput: FragmentOutput;
+    var<private> ORI_VertexVarying: FragmentVarying;
+
+    @fragment
+    fn FragMain(vertex_varying:FragmentVarying) -> FragmentOutput {
+        ORI_VertexVarying = vertex_varying;
+        var texColor = textureSample(baseMap, baseMapSampler, ORI_VertexVarying.fragUV0.xy);
+        var emissive = textureSample(emissiveMap, emissiveMapSampler, ORI_VertexVarying.fragUV0.xy ).rgb;
+        let intensity = materialUniform.emissiveIntensity * materialUniform.emissiveColor.a;
+        emissive = emissive.rgb * materialUniform.emissiveColor.rgb;
+        emissive = convertToHDRRGB(emissive,intensity);
+
+        if (materialUniform.alphaCutoff-texColor.w > 0.0) {
+            discard ;
+        }
+
+        var o_Position = vec4<f32>(ORI_VertexVarying.vWorldPos.xyz,emissive.r) ;
+        var o_Normal = vec4<f32>((ORI_VertexVarying.vWorldNormal.xyz * 0.5 + 0.5 ),emissive.g) ;
+        var o_Color = vec4<f32>((texColor * materialUniform.baseColor).rgb , emissive.b )  ;
+        return FragmentOutput(o_Position,o_Normal,vec4<f32>(o_Color));
+    }
+
+    fn convertToHDRRGB( color: vec3<f32>, ins:f32 ) -> vec3<f32> {
+        var hdrColor = vec3<f32>(0.0,0.0,0.0);
+        hdrColor.r = color.r * pow(2.4, ins);
+        hdrColor.g = color.g * pow(2.4, ins);
+        hdrColor.b = color.b * pow(2.4, ins);
+        return hdrColor;
+    }
+`;

package/dist/src/assets/shader/core/pass/SkyGBuffer_pass.d.ts

@@ -0,0 +1 @@
+export declare let SkyGBuffer_pass: string;

package/dist/src/assets/shader/core/pass/SkyGBuffer_pass.js

@@ -0,0 +1,34 @@
+export let SkyGBuffer_pass = `
+    #include "GlobalUniform"
+    #include "ColorUtil_frag"
+
+    struct uniformData {
+        eyesPos: vec3<f32>,
+        exposure: f32,
+        roughness: f32,
+    };
+
+    struct FragmentOutput {
+        @location(auto) o_Position: vec4<f32>,
+        @location(auto) o_Normal: vec4<f32>,
+        @location(auto) o_Color: vec4<f32>
+    };
+
+    @group(1) @binding(4)
+    var baseMapSampler: sampler;
+    @group(1) @binding(5)
+    var baseMap: texture_cube<f32>;
+
+    @group(2) @binding(0)
+    var<uniform> global: uniformData;
+
+    @fragment
+    fn main(@location(auto) fragUV: vec2<f32>,@location(auto) vClipPos: vec4<f32>, @location(auto) vWorldPos: vec4<f32>, @location(auto) vWorldNormal: vec3<f32> , @builtin(position) fragCoord : vec4<f32> ) -> FragmentOutput {
+        let maxLevel: u32 = textureNumLevels(baseMap);
+        let textureColor:vec3<f32> = textureSampleLevel(baseMap, baseMapSampler, normalize(vWorldPos.xyz), global.roughness * f32(maxLevel) ).xyz;
+        let o_Color = 0.618 * vec4<f32>(LinearToGammaSpace(textureColor) * globalUniform.skyExposure , 1.0);
+        let o_Normal = vec4(vWorldNormal,1.0) ;
+        let o_Position = vec4<f32>(vWorldPos.xyz,100000.0) ;
+        return FragmentOutput(o_Position,o_Normal,o_Color);
+    }
+`;

package/dist/src/assets/shader/core/pass/ZPassShader_cs.d.ts

@@ -0,0 +1 @@
+export declare let ZPassShader_cs: string;

package/dist/src/assets/shader/core/pass/ZPassShader_cs.js

@@ -0,0 +1,14 @@
+export let ZPassShader_cs = `
+    @group(0) @binding(0) var<storage,read_write> visibleBuffer: array<f32>;
+    @group(0) @binding(1) var zBufferTexture: texture_2d<f32>;
+
+    @compute @workgroup_size(8, 8, 1)
+    fn CsMain(@builtin(global_invocation_id) globalInvocation_id: vec3<u32>) {
+        var fragCoord = vec2<i32>(globalInvocation_id.xy);
+        let md = textureLoad(zBufferTexture,fragCoord,0);
+        let meshID = i32(floor(md.w + 0.1));
+        if (meshID >= 0) {
+            visibleBuffer[meshID] = 1.0;
+        }
+    }
+`;

package/dist/src/assets/shader/core/pass/ZPassShader_fs.d.ts

@@ -0,0 +1 @@
+export declare let ZPassShader_fs: string;

package/dist/src/assets/shader/core/pass/ZPassShader_fs.js

@@ -0,0 +1,15 @@
+export let ZPassShader_fs = `
+    #include "GlobalUniform"
+    #include "MathShader"
+    struct FragmentOutput {
+        @location(auto) o_Target: vec4<f32>,
+        @builtin(frag_depth) out_depth: f32
+    };
+
+    @fragment
+    fn main(@location(auto) vID: f32, @location(auto) vPos:vec3<f32>,  @location(auto) vClipPos: vec4<f32>,  @builtin(position) fragCoord : vec4<f32>) -> FragmentOutput {
+        var op = vec4<f32>( vPos, vID);
+        let d = log2Depth(fragCoord.z+0.00001,globalUniform.near,globalUniform.far);
+        return FragmentOutput(op,d);
+    }
+`;

package/dist/src/assets/shader/core/pass/ZPassShader_vs.d.ts

@@ -0,0 +1 @@
+export declare let ZPassShader_vs: string;

package/dist/src/assets/shader/core/pass/ZPassShader_vs.js

@@ -0,0 +1,83 @@
+import { MorphTarget_shader } from "../../../../components/anim/morphAnim/MorphTarget_shader";
+import { SkeletonAnimation_shader } from "../../anim/SkeletonAnimation_shader";
+export let ZPassShader_vs = `
+    #include "GlobalUniform"
+    #include "MathShader"
+    struct VertexOutput {
+        @location(auto) vID: f32 ,
+        @location(auto) vPos: vec3<f32> ,
+        @location(auto) vClipPos: vec4<f32> ,
+        @builtin(position) member: vec4<f32>
+    };
+
+    struct Uniforms {
+        matrix: array<mat4x4<f32>>
+    };
+
+    @group(0) @binding(1)
+    var<storage, read> models: Uniforms;
+    var<private> worldMatrix: mat4x4<f32>;
+
+    #if USE_MORPHTARGETS
+        ${MorphTarget_shader.getMorphTargetShaderBinding(1, 0)}
+    #endif
+
+    #if USE_SKELETON
+        ${SkeletonAnimation_shader.groupBindingAndFunctions(1, 0)}
+    #endif
+
+    @vertex
+    fn main(
+        @builtin(instance_index) index: u32,
+        @location(auto) position: vec3<f32>,
+        @location(auto) normal: vec3<f32>,
+        @location(auto) uv: vec2<f32>,
+        @location(auto) TEXCOORD_1: vec2<f32>,
+
+    #if USE_TANGENT
+        @location(auto) TANGENT: vec4<f32>,
+        #if USE_SKELETON
+            @location(auto) joints0: vec4<f32>,
+            @location(auto) weights0: vec4<f32>,
+            #if USE_JOINT_VEC8
+                @location(auto) joints1: vec4<f32>,
+                @location(auto) weights1: vec4<f32>,
+            #endif
+        #elseif USE_MORPHTARGETS
+            @location(auto) vIndex: f32,
+        #endif
+    #elseif USE_SKELETON
+        @location(auto) joints0: vec4<f32>,
+        @location(auto) weights0: vec4<f32>,
+        #if USE_JOINT_VEC8
+            @location(auto) joints1: vec4<f32>,
+            @location(auto) weights1: vec4<f32>,
+        #endif
+    #elseif USE_MORPHTARGETS
+        @location(auto) vIndex: f32,
+    #endif
+    ) -> VertexOutput {
+        worldMatrix = models.matrix[index];
+        
+        var vertexPosition = position;
+        var vertexNormal = normal;
+        #if USE_MORPHTARGETS
+            ${MorphTarget_shader.getMorphTargetCalcVertex()}
+        #endif
+
+            le wPos = worldMatrix * vec4<f32>(vertexPosition.xyz, 1.0);
+            var fixProjMat = globalUniform.projMat;
+            var rzMatrix: mat4x4<f32>;
+            rzMatrix[0] = vec4<f32>(1.0,0.0,0.0,0.0);
+            rzMatrix[1] = vec4<f32>(0.0,1.0,0.0,0.0);
+            rzMatrix[2] = vec4<f32>(0.0,0.0,1.0,0.0);
+            rzMatrix[3] = vec4<f32>(0.0,0.0,0.0,1.0);
+            var clipPos: vec4<f32> = fixProjMat * globalUniform.viewMat * (wPos);
+            return VertexOutput(f32(index), wPos.xyz, clipPos, clipPos);
+    }
+
+    fn depthToLinear01(depth: f32) -> f32 {
+        let a = 1.0 / (globalUniform.near - globalUniform.far);
+        return (globalUniform.near*globalUniform.far*a) / (depth + globalUniform.far * a);
+    }
+`;

package/dist/src/assets/shader/core/struct/ClusterLight.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 光源集群，仅处理当前像素所在3D集群内的光源
+ */
+export declare let ClusterLight: string;

package/dist/src/assets/shader/core/struct/ClusterLight.js

@@ -0,0 +1,98 @@
+/**
+ * 光源集群，仅处理当前像素所在3D集群内的光源
+ */
+export let ClusterLight = `
+    struct LightData {
+        index:f32,
+        lightType:i32,
+        radius:f32,
+        linear:f32,
+        position:vec3<f32>,
+        lightMatrixIndex:f32,
+        direction:vec3<f32>,
+        quadratic:f32,
+        lightColor:vec3<f32>,
+        intensity:f32,
+        innerCutOff :f32,
+        outerCutOff:f32,
+        range :f32,
+        castShadow:i32,
+        lightTangent:vec3<f32>,
+        ies:f32,
+    };
+
+    const PointLightType = 1;
+    const DirectLightType = 2;
+    const SpotLightType = 3;
+
+    struct ClusterBox {
+        minPoint:vec4<f32>,
+        maxPoint:vec4<f32>
+    };
+
+    struct LightIndex {
+        count:f32,
+        start:f32,
+        empty0:f32,
+        empty1:f32,
+    };
+
+    struct ClustersUniform {
+        clusterTileX:f32,
+        clusterTileY:f32,
+        clusterTileZ:f32,
+        numLights:f32,
+        maxNumLightsPerCluster:f32,
+        near:f32,
+        far:f32,
+        screenWidth:f32,
+        screenHeight:f32,
+        clusterPix:f32, 
+    };
+
+    @group(2) @binding(1)
+    var<storage,read> lightBuffer: array<LightData>;
+    @group(2) @binding(2)
+    var<uniform> clustersUniform: ClustersUniform;
+    @group(2) @binding(3)
+    var<storage,read> lightAssignBuffer : array<f32>;
+    @group(2) @binding(4)
+    var<storage,read> assignTable: array<LightIndex>;
+    #if DEBUG_CLUSTER
+        @group(2) @binding(5)
+        var<storage,read> clusterBuffer: array<ClusterBox>;
+    #endif
+
+    fn getLight(index:i32) -> LightData {
+        let lightId = i32(lightAssignBuffer[index]);
+        var lightData = lightBuffer[lightId];
+        return lightData;
+    }
+
+    fn linearTo01Depth(depth: f32) -> f32 {
+        return (globalUniform.far) * globalUniform.near / fma(depth, globalUniform.near - globalUniform.far, globalUniform.far);
+    }
+
+    fn getClusterId3() -> vec3<u32> {
+        let z = linearTo01Depth(ORI_VertexVarying.fragCoord.z);
+        let sliceScale = f32(clustersUniform.clusterTileZ) / log2(globalUniform.far / globalUniform.near);
+        let sliceBias = -(f32(clustersUniform.clusterTileZ) * log2(globalUniform.near) / log2(globalUniform.far / globalUniform.near));
+        let zTile = u32(max(log2(z) * sliceScale + sliceBias, 0.0));
+        var screenUV = ORI_VertexVarying.fragCoord.xy / vec2<f32>( globalUniform.windowWidth , globalUniform.windowHeight );
+        let i = u32(floor(screenUV.x * clustersUniform.clusterTileX));
+        let j = u32(floor(screenUV.y * clustersUniform.clusterTileY));
+        return vec3<u32>(i,j,zTile);
+    }
+
+    fn getCluster() -> LightIndex {
+        let tile = getClusterId3();
+        let id = tile.x + tile.y * u32(clustersUniform.clusterTileX) + tile.z * u32(clustersUniform.clusterTileX) * u32(clustersUniform.clusterTileY);
+        return assignTable[id];
+    }
+
+    fn getClusterIndex() -> u32 {
+        let tile = getClusterId3();
+        let id = tile.x + tile.y * u32(clustersUniform.clusterTileX) + tile.z * u32(clustersUniform.clusterTileX) * u32(clustersUniform.clusterTileY);
+        return id;
+    }
+`;

package/dist/src/assets/shader/core/struct/ColorPassFragmentOutput.d.ts

@@ -0,0 +1 @@
+export declare let ColorPassFragmentOutput: string;

package/dist/src/assets/shader/core/struct/ColorPassFragmentOutput.js

@@ -0,0 +1,16 @@
+export let ColorPassFragmentOutput = /*wgsl */ `
+    struct FragmentOutput {
+        @location(auto) color: vec4<f32>,
+        #if USE_WORLDPOS
+            @location(auto) worldPos: vec4<f32>,
+        #endif
+        #if USEGBUFFER
+            @location(auto) worldNormal: vec4<f32>,
+            @location(auto) material: vec4<f32>,
+        #endif
+
+        #if USE_OUTDEPTH
+            @builtin(frag_depth) out_depth: f32
+        #endif
+    };
+`;

package/dist/src/assets/shader/core/struct/FragmentOutput.d.ts

@@ -0,0 +1 @@
+export declare let FragmentOutput: string;

package/dist/src/assets/shader/core/struct/FragmentOutput.js

@@ -0,0 +1,18 @@
+export let FragmentOutput = `
+    #if USE_CASTREFLECTION
+        struct FragmentOutput {
+            @location(auto) gBuffer: vec4<f32>,
+            #if USE_OUTDEPTH
+                @builtin(frag_depth) out_depth: f32
+            #endif
+        };
+    #else
+        struct FragmentOutput {
+            @location(auto) color: vec4<f32>,
+            @location(auto) gBuffer: vec4<f32>,
+            #if USE_OUTDEPTH
+                @builtin(frag_depth) out_depth: f32
+            #endif
+        };
+    #endif
+`;

package/dist/src/assets/shader/core/struct/FragmentVarying.d.ts

@@ -0,0 +1 @@
+export declare let FragmentVarying: string;

package/dist/src/assets/shader/core/struct/FragmentVarying.js

@@ -0,0 +1,23 @@
+export let FragmentVarying = `
+    struct FragmentVarying {
+        @location(auto) index: f32,
+        @location(auto) fragUV0: vec2<f32>,
+        @location(auto) fragUV1: vec2<f32>,
+        @location(auto) viewPosition: vec4<f32>,
+        @location(auto) fragPosition: vec4<f32>,
+        @location(auto) vWorldPos: vec4<f32>,
+        @location(auto) vWorldNormal: vec3<f32>,
+        @location(auto) vColor: vec4<f32>,
+
+        #if USE_SHADOWMAPING
+            @location(auto) vShadowPos: vec4<f32>,
+        #endif
+
+        #if USE_TANGENT
+            @location(auto) TANGENT: vec4<f32>,
+        #endif
+
+        @builtin(front_facing) face: bool,
+        @builtin(position) fragCoord : vec4<f32>
+    }
+`;

package/dist/src/assets/shader/core/struct/ShadingInput.d.ts

@@ -0,0 +1 @@
+export declare let ShadingInput: string;

package/dist/src/assets/shader/core/struct/ShadingInput.js

@@ -0,0 +1,21 @@
+export let ShadingInput = `
+    struct ShadingInput {
+        BaseColor: vec4<f32>,
+        Roughness:f32,
+        Metallic:f32,
+        Specular:f32, // 镜面反射强度
+        EmissiveColor:vec4<f32>,
+        SurfaceColor:vec4<f32>,
+        Normal:vec3<f32>,
+        HairNormal:vec3<f32>,
+        Tangent:vec4<f32>, // 切线向量
+        WorldPositionOffset:vec3<f32>, // 世界空间位置偏移
+        AmbientOcclusion:f32,
+        PixelDepthOffset:f32, // 像素深度偏移
+        Opacity:f32,
+        OpacityMask:f32, // 透明度遮罩，通常用于硬边缘透明
+        Refraction:f32, // 折射强度
+        FragDepth:f32, // 自定义片元深度值
+        SSS:vec3f, // 次表面散射
+    }
+`;

package/dist/src/assets/shader/core/struct/VertexAttributeIndexShader.d.ts

@@ -0,0 +1 @@
+export declare let VertexAttributeIndexShader: string;

package/dist/src/assets/shader/core/struct/VertexAttributeIndexShader.js

@@ -0,0 +1,100 @@
+export let VertexAttributeIndexShader = /*wgsl*/ `
+    #include "WorldMatrixUniform"
+    struct VertexAttributes{
+        @builtin(instance_index) index : u32,
+
+        @location(auto) position: vec3<f32>,
+        @location(auto) normal: vec3<f32>,
+        @location(auto) uv: vec2<f32>,
+        @location(auto) TEXCOORD_1: vec2<f32>,
+        @location(auto) vIndex: f32,
+        @location(auto) index2: f32,
+    }
+
+    struct VertexOutput {
+        @location(auto) index: f32,
+        @location(auto) varying_UV0: vec2<f32>,
+        @location(auto) varying_UV1: vec2<f32>,
+        @location(auto) varying_ViewPos: vec4<f32>,
+        @location(auto) varying_Clip: vec4<f32>,
+        @location(auto) varying_WPos: vec4<f32>,
+        @location(auto) varying_WNormal: vec3<f32>,
+        @location(auto) varying_Color: vec4<f32>,
+        #if USE_SHADOWMAPING
+            @location(auto) varying_ShadowPos: vec4<f32>,
+        #endif
+        @builtin(position) member: vec4<f32>
+    };
+
+    struct TransformVertex{
+        position:vec3<f32>,
+        normal:vec3<f32>,
+    }
+
+    struct GraphicNodeStruct{
+        matrixIndex:f32,
+        texIndex:f32,
+        tex2Index:f32,
+        tex3Index:f32,
+
+        fillRotation:f32,
+        empty0:f32,
+        empty1:f32,
+        empty2:f32,
+
+        baseColor:vec4f,
+        lineColor:vec4f,
+        emissiveColor:vec4f,
+        uvRect:vec4f,
+        uvRect2:vec4f,
+        uvSpeed:vec4f,
+    }
+
+    var<private> ORI_VertexOut: VertexOutput ;
+    var<private> worldMatrix: mat4x4<f32> ;
+    var<private> graphicNode: GraphicNodeStruct ;
+
+    fn ORI_Vert(vertex:VertexAttributes){
+        var vertexPosition = vertex.position;
+        var vertexNormal = vertex.normal;
+
+        ORI_VertexOut.index = f32(vertex.vIndex) ;
+        graphicNode = graphicBuffer[u32(round(vertex.vIndex))];
+        let node_Matrix_M = models.matrix[u32(round(graphicNode.matrixIndex))];
+
+        #if USE_TANGENT
+            ORI_VertexOut.varying_Tangent = vertex.TANGENT ;
+        #endif
+
+        ORI_MATRIX_M = node_Matrix_M * ORI_MATRIX_M ;
+
+        #if USE_BILLBOARD
+            let billboardMatrix: mat3x3<f32> = calculateBillboardMatrix2(globalUniform.CameraPos.xyz,ORI_MATRIX_M[3].xyz,globalUniform.cameraWorldMatrix[1].xyz);
+            vertexPosition = billboardMatrix * vertexPosition.xyz;
+        #endif
+
+        worldMatrix = ORI_MATRIX_M ;
+
+        let nMat = mat3x3<f32>(ORI_MATRIX_M[0].xyz,ORI_MATRIX_M[1].xyz,ORI_MATRIX_M[2].xyz) ;
+        ORI_NORMALMATRIX = transpose(inverse( nMat ));
+
+        var worldPos = (ORI_MATRIX_M * vec4<f32>(vertexPosition.xyz, 1.0));
+
+        #if TRANSFORMVERTEX
+            var transformVertex = transformVertex(worldPos.xyz,vertexNormal,vertex);
+            worldPos = vec4<f32>(transformVertex.position ,worldPos.w);
+            vertexNormal = transformVertex.normal ;
+        #endif
+
+        var viewPosition = ORI_MATRIX_V * worldPos;
+        var clipPosition = ORI_MATRIX_P * viewPosition ;
+
+        ORI_VertexOut.varying_UV0 = vertex.uv.xy ;
+        ORI_VertexOut.varying_UV1 = vertex.TEXCOORD_1.xy;
+        ORI_VertexOut.varying_ViewPos = viewPosition ;
+        ORI_VertexOut.varying_Clip = clipPosition;
+        ORI_VertexOut.varying_WPos = worldPos;
+        ORI_VertexOut.varying_WNormal = normalize( vertexNormal.xyz);
+        ORI_VertexOut.member = clipPosition ;
+    }
+`;

package/dist/src/assets/shader/core/struct/VertexAttributes.d.ts

@@ -0,0 +1 @@
+export declare let VertexAttributes_vert: string;