@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/core/common/GlobalUniform.js

@@ -0,0 +1,117 @@
+import { CSM } from "../../../../core/csm/CSM";
+/**
+ * @internal
+ */
+export let GlobalUniform = /*wgsl*/ `
+
+  #include "MathShader"
+
+  struct GlobalUniform {
+
+    projMat: mat4x4<f32>,
+    viewMat: mat4x4<f32>,
+    cameraWorldMatrix: mat4x4<f32>,
+    pvMatrixInv : mat4x4<f32>,
+    viewToWorld : mat4x4<f32>,
+    shadowMatrix: array<mat4x4<f32>, 8u>,
+
+    csmShadowBias: vec4<f32>,
+
+    csmMatrix: array<mat4x4<f32>,${CSM.Cascades}>,
+    
+    shadowLights:mat4x4<f32>,
+
+    reflectionProbeSize:f32,
+    reflectionProbeMaxCount:f32,
+    reflectionMapWidth:f32,
+    reflectionMapHeight:f32,
+
+    reflectionCount:f32,
+    test2:f32,
+    test3:f32,
+    test4:f32,
+
+    CameraPos: vec3<f32>,
+    frame: f32,
+    SH:  array<vec4f, 9u> ,
+
+    time: f32,
+    delta: f32,
+    shadowBias: f32,
+    skyExposure: f32,
+
+    renderPassState:f32,
+    quadScale: f32,
+    hdrExposure: f32,
+    renderState_left: i32,
+
+    renderState_right: i32,
+    renderState_split: f32,
+    mouseX: f32,
+    mouseY: f32,
+
+    windowWidth: f32,
+    windowHeight: f32,
+    near: f32,
+    far: f32,
+
+    pointShadowBias: f32,
+    shadowMapSize: f32,
+    shadowSoft: f32,
+    enableCSM:f32,
+
+
+    csmMargin:f32,
+    nDirShadowStart: i32,
+    nDirShadowEnd: i32,
+    nPointShadowStart: i32,
+
+    nPointShadowEnd: i32,
+    cameraForward:vec3f,
+
+    frustumPlanes: array<vec4f, 6u>,
+
+  };
+
+  @group(0) @binding(0)
+  var<uniform> globalUniform: GlobalUniform;
+
+  fn getViewPosition(z:f32,uv:vec2f) -> vec3f {
+    let pvMatrixInv = globalUniform.pvMatrixInv ;
+    let clip = vec4<f32>((uv * 2.0 - 1.0) , z , 1.0);
+    var viewPos = pvMatrixInv * clip ;
+    return viewPos.xyz / viewPos.w ;
+  }
+
+  fn getWorldPosition(z:f32,uv:vec2f) -> vec3f {
+    let viewToWorld = globalUniform.viewToWorld ;
+    let clip = vec4<f32>((uv * 2.0 - 1.0) , z , 1.0);
+    var worldPos = viewToWorld * clip ;
+    worldPos = worldPos / worldPos.w ;
+    return worldPos.xyz ;
+  }
+
+  var<private> NORMALMATRIX_INV : mat3x3<f32> ;
+  var<private> NORMALMATRIX : mat3x3<f32> ;
+  fn useNormalMatrix()  {
+     let finalMatrix = globalUniform.projMat * globalUniform.viewMat ;
+     let nMat = mat3x3<f32>(finalMatrix[0].xyz,finalMatrix[1].xyz,finalMatrix[2].xyz) ;
+     NORMALMATRIX = transpose(inverse( nMat ));
+  }
+
+  fn useNormalMatrixInv()  {
+    let finalMatrix = globalUniform.projMat * globalUniform.viewMat ;
+    let nMat = mat3x3<f32>(finalMatrix[0].xyz,finalMatrix[1].xyz,finalMatrix[2].xyz) ;
+    NORMALMATRIX_INV = transpose(( nMat ));
+  }
+
+  fn getWorldNormal(viewNormal:vec3f) -> vec3f {
+    var worldNormal = NORMALMATRIX_INV * viewNormal ;
+    return normalize(worldNormal.xyz);
+  }
+
+  fn getViewNormal(worldNormal:vec3f) -> vec3f {
+    var viewNormal = globalUniform.viewMat * vec4f(worldNormal,0.0) ;
+    return normalize(viewNormal.xyz);
+  }
+`;

package/dist/src/assets/shader/core/common/InstanceUniform.d.ts

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

package/dist/src/assets/shader/core/common/InstanceUniform.js

@@ -0,0 +1,9 @@
+export let InstanceUniform = `
+    #if USE_INSTANCEDRAW
+        struct InstanceUniform {
+            matrixIDs: array<i32>
+        };
+        @group(2) @binding(7)
+        var<storage, read> instanceDrawID: InstanceUniform;
+    #endif
+`;

package/dist/src/assets/shader/core/common/SHCommon_frag.d.ts

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

package/dist/src/assets/shader/core/common/SHCommon_frag.js

@@ -0,0 +1,82 @@
+export let SHCommon_frag = `
+
+fn Y0(v : vec3f ) -> f32 {
+     return ((1.0 / 2.0) * sqrt(1.0 / PI)); 
+}
+
+fn Y1(v: vec3f ) -> f32 {
+    return ( sqrt(3.0 / (4.0 * PI)) * v.z );
+}
+
+fn Y2(v: vec3f ) -> f32 { 
+    return (sqrt(3.0 / (4.0 * PI)) * v.y);
+}
+
+fn Y3(v: vec3f ) -> f32 {  
+    return (sqrt(3.0 / (4.0 * PI)) * v.x);
+}
+
+fn Y4(v: vec3f ) -> f32 { 
+    return (1.0 / 2.0 * sqrt(15.0 / PI) * v.x * v.z);
+}
+
+fn Y5(v: vec3f ) -> f32 { 
+    return (1.0 / 2.0 * sqrt(15.0 / PI) * v.z * v.y);
+}
+
+fn Y6(v: vec3f ) -> f32 { 
+    return (1.0 / 4.0 * sqrt(5.0 / PI) * (-v.x * v.x - v.z * v.z + 2.0 * v.y * v.y));
+}
+
+fn Y7(v: vec3f ) -> f32 { 
+    return (1.0 / 2.0 * -sqrt(15.0 / PI) * v.y * v.x);
+}
+
+fn Y8(v: vec3f ) -> f32 { 
+    return (1.0 / 4.0 * sqrt(15.0 / PI) * (v.x * v.x - v.z * v.z));
+}
+
+fn Y9(v: vec3f ) -> f32 { 
+    return (1.0 / 4.0 * sqrt(35.0 / (2.0 * PI)) * (3.0 * v.x * v.x - v.z * v.z) * v.z);
+}
+
+fn Y10(v: vec3f ) -> f32 { 
+    return ( 1.0 / 2.0 * sqrt(105.0 / PI) * v.x * v.z * v.y );
+}
+
+fn Y11(v: vec3f ) -> f32 { 
+    return ( 1.0 / 4.0 * sqrt(21.0 / (2.0 * PI)) * v.z * (4.0 * v.y * v.y - v.x * v.x - v.z * v.z) );
+}
+
+fn Y12(v: vec3f ) -> f32 { 
+    return ( 1.0 / 4.0 * sqrt(7.0 / PI) * v.y * (2 * v.y * v.y - 3.0 * v.x * v.x - 3.0 * v.z * v.z) );
+}
+
+fn Y13(v: vec3f ) -> f32 { 
+    return ( 1.0 / 4.0 * sqrt(21.0 / (2.0 * PI)) * v.x * (4.0 * v.y * v.y - v.x * v.x - v.z * v.z) );
+}
+
+fn Y14(v: vec3f ) -> f32 { 
+    return ( 1.0 / 4.0 * sqrt(105.0 / PI) * (v.x * v.x - v.z * v.z) * v.y );
+}
+
+fn Y15(v: vec3f ) -> f32 { 
+    return ( 1.0 / 4.0 * sqrt(35.0 / (2.0 * PI)) * (v.x * v.x - 3.0 * v.z * v.z) * v.x );
+}
+
+fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
+    let N: vec3<f32> = vec3<f32>(dir.z, dir.y, dir.x);
+    let v: vec3<f32> = normalize(N);
+    let color = coefficients[0] * Y0(v)  
+        + coefficients[1] * Y1(v) 
+        + coefficients[2] * Y2(v) 
+        + coefficients[3] * Y3(v) 
+        + coefficients[4] * Y4(v) 
+        + coefficients[5] * Y5(v) 
+        + coefficients[6] * Y6(v) 
+        + coefficients[7] * Y7(v)  
+        + coefficients[8] * Y8(v) 
+    ;
+    return vec4(color.rgb,1.0);
+}
+`;

package/dist/src/assets/shader/core/common/WorldMatrixUniform.d.ts

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

package/dist/src/assets/shader/core/common/WorldMatrixUniform.js

@@ -0,0 +1,8 @@
+export let WorldMatrixUniform = /*wgsl*/ `
+    struct Uniforms {
+        matrix : array<mat4x4<f32>>
+    };
+
+    @group(0) @binding(1)
+    var<storage, read> models : Uniforms;
+`;

package/dist/src/assets/shader/core/inline/Inline_vert.d.ts

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

package/dist/src/assets/shader/core/inline/Inline_vert.js

@@ -0,0 +1,59 @@
+export let Inline_vert = /*wgsl*/ `
+    #include "MathShader"
+    #include "FastMathShader"
+    #include "InstanceUniform"
+
+    var<private> ORI_MATRIX_P: mat4x4<f32>;
+    var<private> ORI_MATRIX_V: mat4x4<f32>;
+    var<private> ORI_MATRIX_M: mat4x4<f32>;
+    var<private> ORI_MATRIX_PV: mat4x4<f32>;
+    var<private> ORI_MATRIX_PVInv: mat4x4<f32>;
+    var<private> ORI_MATRIX_World: mat4x4<f32>;
+    var<private> ORI_CAMERAMATRIX: mat4x4<f32>;
+    var<private> ORI_NORMALMATRIX: mat3x3<f32>;
+    var<private> ORI_CameraWorldDir: vec3<f32>;
+    var<private> ORI_ViewDir: vec3<f32>;
+
+    fn TIME() -> vec3f {
+        return vec3f(globalUniform.frame, globalUniform.time , globalUniform.delta);
+    }
+
+    fn TIME_frame() -> f32 {
+        return globalUniform.frame ;
+    }
+
+    fn TIME_time() -> f32 {
+        return globalUniform.time ;
+    }
+
+    fn TIME_delta() -> f32 {
+        return globalUniform.delta ;
+    }
+
+    fn MOUSE() -> vec2f {
+        return vec2f( globalUniform.mouseX, globalUniform.mouseY) ;
+    }
+
+    fn SCREEN() -> vec2f {
+        return vec2f( globalUniform.windowWidth, globalUniform.windowHeight) ;
+    }
+
+    fn ProjectionParams() -> vec3f {
+        return vec3f( globalUniform.near, globalUniform.far,1.0 + 1.0 / globalUniform.far) ;
+    }
+
+    fn vertex_inline(vertex:VertexAttributes){
+        ORI_MATRIX_P = globalUniform.projMat ;
+        ORI_MATRIX_V = globalUniform.viewMat ;
+        ORI_MATRIX_PV = ORI_MATRIX_P * ORI_MATRIX_V ;
+        ORI_MATRIX_PVInv = globalUniform.pvMatrixInv ;
+        ORI_CAMERAMATRIX = globalUniform.cameraWorldMatrix ;
+
+        ORI_MATRIX_M = models.matrix[u32(vertex.index)];
+            
+        #if USE_INSTANCEDRAW
+            let modelID = instanceDrawID.matrixIDs[vertex.index];
+            ORI_MATRIX_M = models.matrix[modelID];
+        #endif
+    }
+`;

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

@@ -0,0 +1,4 @@
+export declare let shadowCastMap_vert: string;
+export declare let castPointShadowMap_vert: string;
+export declare let shadowCastMap_frag: string;
+export declare let directionShadowCastMap_frag: string;

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

@@ -0,0 +1,284 @@
+import { SkeletonAnimation_shader } from "../../anim/SkeletonAnimation_shader";
+import { MorphTarget_shader } from "../../../../components/anim/morphAnim/MorphTarget_shader";
+export let shadowCastMap_vert = `
+#include "WorldMatrixUniform"
+#include "GlobalUniform"
+
+struct VertexOutput {
+    @location(auto) fragUV: vec2<f32>,
+    @builtin(position) member: vec4<f32>
+};
+
+#if USE_MORPHTARGETS
+    ${MorphTarget_shader.getMorphTargetShaderBinding(2, 1)}
+#endif
+
+#if USE_SKELETON
+    ${SkeletonAnimation_shader.groupBindingAndFunctions(2, 1)} 
+#endif
+
+var<private> worldMatrix: mat4x4<f32>;
+
+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>,
+
+    #if USE_METAHUMAN
+        #if USE_TANGENT
+            @location(auto) TANGENT: vec4<f32>,
+            @location(auto) joints0: vec4<f32>,
+            @location(auto) weights0: vec4<f32>,
+            #if USE_JOINT_VEC8
+                @location(auto) joints1: vec4<f32>,
+                @location(auto) weights1: vec4<f32>,
+                @location(auto) vIndex: f32,
+            #else
+                @location(auto) vIndex: f32,
+            #endif
+        #else
+            @location(auto) joints0: vec4<f32>,
+            @location(auto) weights0: vec4<f32>,
+            #if USE_JOINT_VEC8
+                @location(auto) joints1: vec4<f32>,
+                @location(auto) weights1: vec4<f32>,
+                @location(auto) vIndex: f32,
+            #else
+                @location(auto) vIndex: f32,
+            #endif
+        #endif
+    #else
+        #if USE_TANGENT
+            @location(auto) TANGENT: vec4<f32>,
+        #endif
+
+        #if USE_SKELETON
+            #if USE_TANGENT
+                @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
+            #else
+                @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
+            #endif
+        #endif
+
+        #if USE_MORPHTARGETS
+            #if USE_TANGENT
+                @location(auto) vIndex: f32,
+            #else
+                @location(auto) vIndex: f32,
+            #endif
+        #endif
+
+    #endif
+}
+
+@vertex
+fn main(vertex:VertexAttributes) -> VertexOutput {
+    worldMatrix = models.matrix[vertex.index];
+    let shadowMatrix: mat4x4<f32> = globalUniform.projMat * globalUniform.viewMat ;
+    var vertexPosition = vertex.position.xyz;
+    var vertexNormal = vertex.normal.xyz;
+
+    #if USE_MORPHTARGETS
+     ${MorphTarget_shader.getMorphTargetCalcVertex()}    
+    #endif
+
+    #if USE_SKELETON
+        #if USE_JOINT_VEC8
+          worldMatrix *= getSkeletonWorldMatrix_8(vertex.joints0, vertex.weights0, vertex.joints1, vertex.weights1);
+        #else
+          worldMatrix *= getSkeletonWorldMatrix_4(vertex.joints0, vertex.weights0);
+        #endif
+    #endif
+
+    var worldPos = worldMatrix * vec4<f32>(vertexPosition, 1.0) ;
+    var vPos = shadowMatrix * worldPos;
+    return VertexOutput(vertex.uv, vPos );  
+}
+`;
+export let castPointShadowMap_vert = `
+#include "WorldMatrixUniform"
+#include "GlobalUniform"
+
+struct VertexOutput {
+    @location(auto) fragUV: vec2<f32>,
+    @location(auto) worldPos: vec3<f32>,
+    @builtin(position) member: vec4<f32>
+};
+
+#if USE_MORPHTARGETS
+    ${MorphTarget_shader.getMorphTargetShaderBinding(2, 1)}
+#endif
+
+#if USE_SKELETON
+    ${SkeletonAnimation_shader.groupBindingAndFunctions(2, 1)} 
+#endif
+
+var<private> worldMatrix: mat4x4<f32>;
+
+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>,
+
+  
+  #if USE_METAHUMAN
+    #if USE_TANGENT
+        @location(auto) TANGENT: vec4<f32>,
+        @location(auto) joints0: vec4<f32>,
+        @location(auto) weights0: vec4<f32>,
+        @location(auto) joints1: vec4<f32>,
+        @location(auto) weights1: vec4<f32>,
+        @location(auto) vIndex: f32,
+    #else
+        @location(auto) joints0: vec4<f32>,
+        @location(auto) weights0: vec4<f32>,
+        @location(auto) joints1: vec4<f32>,
+        @location(auto) weights1: vec4<f32>,
+        @location(auto) vIndex: f32,
+    #endif
+    #else
+    #if USE_TANGENT
+        @location(auto) TANGENT: vec4<f32>,
+    #endif
+
+    #if USE_SKELETON
+        #if USE_TANGENT
+            @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
+        #else
+            @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
+        #endif
+    #endif
+
+    #if USE_MORPHTARGETS
+        #if USE_TANGENT
+            @location(auto) vIndex: f32,
+        #else
+            @location(auto) vIndex: f32,
+        #endif
+    #endif
+
+    #endif
+}
+
+@vertex
+fn main(vertex:VertexAttributes) -> VertexOutput {
+    worldMatrix = models.matrix[vertex.index];
+    let shadowMatrix: mat4x4<f32> = globalUniform.projMat * globalUniform.viewMat ;
+    var vertexPosition = vertex.position.xyz;
+
+    #if USE_METAHUMAN
+        ${MorphTarget_shader.getMorphTargetCalcVertex()}
+        #if USE_JOINT_VEC8
+            worldMatrix *= getSkeletonWorldMatrix_8(vertex.joints0, vertex.weights0, vertex.joints1, vertex.weights1);
+        #else
+            worldMatrix *= getSkeletonWorldMatrix_4(vertex.joints0, vertex.weights0);
+        #endif
+    #endif
+
+    #if USE_MORPHTARGETS
+        ${MorphTarget_shader.getMorphTargetCalcVertex()}
+    #endif
+
+    #if USE_SKELETON
+        #if USE_JOINT_VEC8
+          worldMatrix *= getSkeletonWorldMatrix_8(vertex.joints0, vertex.weights0, vertex.joints1, vertex.weights1);
+        #else
+          worldMatrix *= getSkeletonWorldMatrix_4(vertex.joints0, vertex.weights0);
+        #endif
+    #endif
+
+    var worldPos = worldMatrix * vec4<f32>(vertexPosition, 1.0);
+    var vPos = shadowMatrix * worldPos;
+    return VertexOutput(vertex.uv, worldPos.xyz, vPos); 
+}
+`;
+export let shadowCastMap_frag = `
+    #if USE_ALPHACUT
+      @group(1) @binding(0)
+      var baseMapSampler: sampler;
+      @group(1) @binding(1)
+      var baseMap: texture_2d<f32>;
+    #endif
+
+    struct FragmentOutput {
+        @location(auto) o_Target: vec4<f32>,
+        @builtin(frag_depth) out_depth: f32
+    };
+
+    struct MaterialUniform {
+      lightWorldPos: vec3<f32>,
+      cameraFar: f32,
+    };
+
+    @group(2) @binding(0)
+    var<uniform> materialUniform: MaterialUniform;
+
+    @fragment
+    fn main(@location(auto) fragUV: vec2<f32> , @location(auto) worldPos:vec3<f32>) -> FragmentOutput {
+        var distance = length(worldPos.xyz - materialUniform.lightWorldPos);
+        distance = distance / materialUniform.cameraFar;
+        var fragOut: FragmentOutput;
+
+        #if USE_ALPHACUT
+            let Albedo = textureSample(baseMap, baseMapSampler, fragUV);
+            if(Albedo.w > 0.5){
+                fragOut = FragmentOutput(vec4<f32>(0.0), distance);
+            }
+        #else
+            fragOut = FragmentOutput(vec4<f32>(0.0), distance);
+        #endif
+
+        return fragOut;
+    }
+`;
+export let directionShadowCastMap_frag = `
+    #if USE_ALPHACUT
+        @group(1) @binding(0)
+        var baseMapSampler: sampler;
+        @group(1) @binding(1)
+        var baseMap: texture_2d<f32>;
+    #endif
+
+    struct FragmentOutput {
+        @location(auto) o_Target: vec4<f32>,
+        @builtin(frag_depth) out_depth: f32
+    };
+
+    struct MaterialUniform {
+        lightWorldPos: vec3<f32>,
+        cameraFar: f32,
+    }
+
+    @group(2) @binding(0)
+    var<uniform> materialUniform: MaterialUniform;
+
+    @fragment
+    fn main(@location(auto) fragUV: vec2<f32> , @location(auto) clipPos:vec3<f32> ) -> FragmentOutput {
+        var fragOut:FragmentOutput;
+        return fragOut;
+    }
+`;

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

@@ -0,0 +1,4 @@
+/**
+ * 视锥体剔除
+ */
+export declare let FrustumCulling_cs: string;

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

@@ -0,0 +1,91 @@
+/**
+ * 视锥体剔除
+ */
+export let FrustumCulling_cs = /*wgsl*/ `
+#include "GlobalUniform"
+
+struct RenderBound{
+    index:f32,
+}
+
+struct Uniforms {
+    matrix: array<mat4x4<f32>>
+};
+
+@group(0) @binding(1) var<storage, read> models : Uniforms;
+@group(0) @binding(2) var<storage, read> planes: array<vec4<f32>,7>;
+@group(0) @binding(3) var<storage, read> cullingList: array<RenderBound>;
+@group(0) @binding(4) var<storage,read_write> outBuffer: array<f32>;
+
+var<private> boundPoints: array<vec4<f32>,8>;
+
+fn IsInClipSpace( coord : vec4<f32> ) -> bool {
+    return -coord.w <= coord.x && coord.x <= coord.w
+        && -coord.w <= coord.y && coord.y <= coord.w
+        && -coord.w <= coord.z && coord.z <= coord.w;
+}
+
+fn IsOutsideThePlane( plane: vec4<f32>, pointPosition : vec3<f32> ) -> bool{
+    if(dot(plane.xyz, pointPosition) + plane.w > 0.0){
+        return true;
+    }
+    return false;
+}
+
+fn containsBox( size:vec3<f32> , center:vec3<f32> ) -> f32 {
+    var c = 0.0 ;
+    var d = 0.0 ;
+
+    var r = max(size.x, size.y);
+    var sr = max(r , size.z);
+    var scx = center.x;
+    var scy = center.y;
+    var scz = center.z;
+
+    for(var p:i32 = 0; p < 6 ; p = p + 1 ){
+        var plane = planes[p];
+        d = plane.x * scx + plane.y * scy + plane.z * scz + plane.w;
+        if (d <= -sr) {
+        return 0.0;
+        }
+        if (d > sr) {
+        c+=1.0;
+        }
+    }
+
+    if( c >= 6.0 ){
+        return 2.0 ;
+    }else{
+        return 1.0 ;
+    };
+}
+
+@compute @workgroup_size(128)
+fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invocation_id) globalInvocation_id: vec3<u32>){
+    let id = globalInvocation_id.x ;
+    if(id + 1u > u32(planes[6].x)){
+        outBuffer[id] = f32(0.0); 
+        return ;
+    }
+
+    let renderBound = cullingList[id];
+    let boundID = i32(renderBound.index);
+    var plane = planes[0];
+
+    let worldMatrix = models.matrix[boundID];
+    let projMat = globalUniform.projMat;
+
+    let const_boundMin: vec3<f32> = vec3<f32>(-0.5,-0.5,-0.5);   
+    let const_boundMax: vec3<f32> = vec3<f32>(0.5,0.5,0.5);   
+
+    let boundMin = worldMatrix * vec4<f32>(const_boundMin, 1.0);
+    let boundMax = worldMatrix * vec4<f32>(const_boundMax, 1.0);
+
+    let size = abs(boundMax.xyz - boundMin.xyz) * 0.65;
+    let center = worldMatrix[3].xyz;
+
+    var isIn:f32 = 0.0 ;
+    isIn = containsBox(size,center);
+    outBuffer[id] = f32(isIn); 
+}
+`;

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

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