@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/shader/lighting/Irradiance_frag.js

@@ -0,0 +1,270 @@
+/**
+ * 漫反射全局光照
+ */
+export let Irradiance_frag = `
+    #include "IrradianceVolumeData_frag"
+        struct IrradianceField {
+            probeStartPosition: vec4<f32>, // 探针网格起始位置
+            probeCounts:vec4<f32>,
+            probeStep:f32, // 探针间距
+            irradianceTextureWidth:f32,
+            irradianceTextureHeight:f32,
+            irradianceProbeSideLength:f32,
+        };
+
+        @group(1) @binding(auto)
+        var irradianceMapSampler: sampler;
+        @group(1) @binding(auto)
+        var irradianceMap: texture_2d<f32>;
+        @group(1) @binding(auto)
+        var irradianceDepthMapSampler: sampler;
+        @group(1) @binding(auto)
+        var irradianceDepthMap: texture_2d<f32>;
+        @group(2) @binding(7)
+        var<uniform> irradianceData : IrradianceVolumeData;
+
+        var<private> irradianceFieldSurface: IrradianceField;
+        var<private> energyPreservation: f32 = 0.85;
+        var<private> quaternion:vec4<f32> = vec4<f32>(0.0, -0.7071067811865475, 0.7071067811865475, 0.0);
+
+        fn getIrradianceFieldSurface() -> IrradianceField{
+            let data = irradianceData ;
+            irradianceFieldSurface.probeStartPosition = vec4<f32>(data.startX, data.startY, data.startZ, 0.0);
+            irradianceFieldSurface.probeCounts = vec4<f32>(data.gridXCount, data.gridYCount, data.gridZCount, 0.0);
+            irradianceFieldSurface.probeStep = data.ProbeSpace;
+            irradianceFieldSurface.irradianceTextureWidth = data.OctRTMaxSize;
+            irradianceFieldSurface.irradianceTextureHeight = data.OctRTMaxSize;
+            irradianceFieldSurface.irradianceProbeSideLength = data.OctRTSideSize;
+            return irradianceFieldSurface;
+        }
+
+        fn rotateDir(n:vec3<f32>) -> vec3<f32>{
+            return normalize(applyQuaternion(-n, quaternion));
+        }
+
+        fn square1f(v:f32) -> f32 {
+            return v * v ;
+        }
+
+        fn square(v:vec3<f32>) -> vec3<f32>{
+            return v*v;
+        }
+
+        fn getIrradiance() -> vec4<f32>{
+            var irradiance = sampleIrradianceField();
+            var outerVolumeFactor:f32 = getOuterVolume(irradianceFieldSurface, ORI_VertexVarying.vWorldPos.xyz);
+            irradiance *= outerVolumeFactor;
+        return irradiance ;
+        }
+        
+        fn debugProbe(id:i32) -> vec4<f32>{
+            getIrradianceFieldSurface();
+            var direction = normalize(ORI_VertexVarying.vWorldNormal);
+            direction = applyQuaternion(-direction, quaternion);
+            var probeTextureUV : vec2<f32> = textureCoordFromDirection(normalize(direction),
+                id,
+                irradianceFieldSurface.irradianceTextureWidth,
+                irradianceFieldSurface.irradianceTextureHeight,
+                irradianceFieldSurface.irradianceProbeSideLength);
+
+            var probeIrradiance: vec4<f32> = textureSampleLevel(irradianceMap, irradianceMapSampler, probeTextureUV ,0.0);
+            return probeIrradiance;
+        }
+
+        fn debugProbeDepth(id:i32) -> vec4<f32>{
+            getIrradianceFieldSurface();
+            var direction = normalize(ORI_VertexVarying.vWorldNormal);
+            direction = applyQuaternion(-direction, quaternion);
+            var probeTextureUV : vec2<f32> = textureCoordFromDirection(normalize(direction),
+                id,
+                irradianceFieldSurface.irradianceTextureWidth,
+                irradianceFieldSurface.irradianceTextureHeight,
+                irradianceFieldSurface.irradianceProbeSideLength);
+            
+            var probeIrradiance: vec4<f32> = textureSampleLevel(irradianceDepthMap, irradianceDepthMapSampler, probeTextureUV ,0.0);
+            probeIrradiance.x = probeIrradiance.x / irradianceData.maxDistance;
+            probeIrradiance.y = 0.0;
+            probeIrradiance.z = 0.0;
+            probeIrradiance.w = 1.0;
+            return probeIrradiance;
+        }
+
+        fn getOuterVolume(L:IrradianceField, position:vec3<f32>) -> f32{
+            let halfWidth:vec3<f32> = 0.5 * (L.probeCounts.xyz - 1.0) * L.probeStep;
+            let edgeWidth:vec3<f32> = halfWidth + L.probeStep;
+            let centerPosition:vec3<f32> = halfWidth + L.probeStartPosition.xyz;
+            let clampPos = min(edgeWidth, abs(position - centerPosition));
+            
+            let factorX = getOuterAxis(clampPos.x, edgeWidth.x, L.probeStep);
+            let factorY = getOuterAxis(clampPos.y, edgeWidth.y, L.probeStep);
+            let factorZ = getOuterAxis(clampPos.z, edgeWidth.z, L.probeStep);
+            return factorX * factorY * factorZ;
+        }
+
+        fn getOuterAxis(current:f32, edge:f32, space:f32) -> f32{
+            return clamp((edge - current) / space, 0.0, 1.0);
+        }
+
+        fn getBaseGridCoord(L:IrradianceField, X:vec3<f32>) -> vec3<i32> {
+            var offsetIndex = (X - L.probeStartPosition.xyz) / irradianceFieldSurface.probeStep;
+            return clamp(vec3<i32>(offsetIndex.xyz), vec3<i32>(0), vec3<i32>(L.probeCounts.xyz) - 1);
+        }
+
+        fn gridCoordToProbeIndex(L:IrradianceField, grid:vec3<i32>) -> i32
+        {
+            return grid.x + i32(L.probeCounts.x) * grid.z + grid.y * i32(L.probeCounts.z * L.probeCounts.x);
+        }
+
+        fn gridCoordToPosition(L:IrradianceField, grid:vec3<i32>) -> vec3<f32>
+        {
+            var pos:vec3<f32> = vec3<f32>(grid.xyz) * L.probeStep + L.probeStartPosition.xyz;
+            return pos;
+        }
+
+        fn textureCoordFromDirection(dir:vec3<f32>, probeIndex:i32, width:f32, height:f32, sideLength:f32) -> vec2<f32>
+        {
+            var uv = getWriteOctUVByID(dir, u32(probeIndex), sideLength) ;
+            uv.x = uv.x / irradianceFieldSurface.irradianceTextureWidth;
+            uv.y = uv.y / irradianceFieldSurface.irradianceTextureHeight;
+            return uv ;
+        }
+
+        fn getWriteOctUVByID(dir:vec3<f32> , probeID:u32, size: f32) -> vec2<f32>
+        {
+            var blockCount = u32(irradianceFieldSurface.probeCounts.x * irradianceFieldSurface.probeCounts.z) ;
+            var offsetX = (probeID % blockCount) % u32(irradianceFieldSurface.probeCounts.x) ;
+            var offsetY = u32(irradianceFieldSurface.probeCounts.z - 1.0) - (probeID % blockCount) / u32(irradianceFieldSurface.probeCounts.x) ;
+            var offsetZ = probeID / blockCount ;
+
+            var pixelCoord = (( octEncode(dir) + 1.0 ) * 0.5) * vec2<f32>(size,size) ;
+
+            var blockOffset = vec2<f32>(0.0);
+            blockOffset.x = f32(offsetX) * size;
+            blockOffset.y = f32(offsetY) * size + f32(offsetZ) * irradianceFieldSurface.probeCounts.z * size;
+
+            let mapHeight = u32(irradianceFieldSurface.irradianceTextureHeight);
+            var probeCounts:vec3<f32> = irradianceFieldSurface.probeCounts.xyz;
+
+            var gridOffsetFrom = vec2<i32>(blockOffset) + 1;
+            var gridOffsetTo = offsetByCol(gridOffsetFrom, size, mapHeight, probeCounts);
+
+            pixelCoord = pixelCoord + vec2<f32>(gridOffsetTo - 1) + vec2<f32>(vec2<i32>(vec2<f32>(gridOffsetTo) / size) * 2);
+
+            return pixelCoord + 1.0 ;
+        }
+
+        fn offsetByCol(pixelCoord0:vec2<i32>, octSideSize:f32, mapHeight:u32, counts:vec3<f32>) -> vec2<i32>
+        {
+            var pixelCoord = pixelCoord0;
+            let blockSize:vec2<i32> = vec2<i32>(i32(octSideSize * counts.x),  i32(octSideSize * counts.z));
+            let blockSizeYBorder:i32 = i32((octSideSize + 2.0) * counts.z);
+            let blockMaxRowBorder:i32 = i32(mapHeight) / blockSizeYBorder;
+            let pixelCountYMax:i32 = blockMaxRowBorder * i32(octSideSize * counts.z);
+            let col:i32 = pixelCoord.y / pixelCountYMax;
+            pixelCoord.x = col * i32(octSideSize * counts.x) + pixelCoord.x;
+            pixelCoord.y = pixelCoord.y % pixelCountYMax;
+            return pixelCoord;
+        }
+
+        var<private> wpNormal:vec3<f32> ;
+        fn sampleIrradianceField() -> vec4<f32>{
+            wpNormal = ORI_ShadingInput.Normal.xyz ;
+            var wo:vec3<f32> = ORI_CameraWorldDir ;
+            var wsN:vec3<f32> = normalize(wpNormal);
+            var direction:vec3<f32> = wpNormal;
+            var worldPosition: vec3<f32> = ORI_VertexVarying.vWorldPos.xyz;
+    
+            getIrradianceFieldSurface();
+
+            let surfaceBias = (wsN + 3.0 * wo) * irradianceData.normalBias ;
+
+            var irradiance = vec3<f32>(0.0, 0.0, 0.0);
+            var accumulatedWeights = 0.0;
+            var biasedWorldPosition = (worldPosition + surfaceBias);
+
+            var baseProbeCoords: vec3<i32> = getBaseGridCoord(irradianceFieldSurface, worldPosition);
+            
+            var baseProbeWorldPosition: vec3<f32> = gridCoordToPosition(irradianceFieldSurface, baseProbeCoords) ;
+            
+            var gridSpaceDistance = (biasedWorldPosition - baseProbeWorldPosition);
+
+            var alpha: vec3<f32> = clamp(gridSpaceDistance / (irradianceFieldSurface.probeStep), vec3<f32>(0.0), vec3<f32>(1.0));
+            for (var i:i32 = 0; i < 8; i = i + 1) {
+                var adjacentProbeOffset : vec3<i32> = vec3<i32>(i, i32(f32(i) * 0.5), i32(f32(i) * 0.25)) & vec3<i32>(1);
+                var adjacentProbeCoords: vec3<i32> = clamp(baseProbeCoords + adjacentProbeOffset, vec3<i32>(0),  vec3<i32>(irradianceFieldSurface.probeCounts.xyz) - 1) ;
+                
+                var adjacentProbeIndex :i32 = gridCoordToProbeIndex(irradianceFieldSurface, adjacentProbeCoords);
+                var adjacentProbeWorldPosition :vec3<f32> = gridCoordToPosition(irradianceFieldSurface, adjacentProbeCoords) ;//+ (wsN + 3.0 * w_o) * globalUniform.normalBias;
+            
+                var worldPosToAdjProbe = normalize(adjacentProbeWorldPosition - worldPosition);
+                var biasedPosToAdjProbe = normalize(adjacentProbeWorldPosition - biasedWorldPosition);
+                var biasedPosToAdjProbeDist = length(adjacentProbeWorldPosition - biasedWorldPosition);
+
+                let trilinear = max(vec3<f32>(0.001), mix(1.0 - alpha, alpha, vec3<f32>(adjacentProbeOffset)));
+                let trilinearWeight = (trilinear.x * trilinear.y * trilinear.z);
+                var weight = 1.0;
+
+                var wrapShading = (dot(worldPosToAdjProbe, direction) + 1.0) * 0.5;
+                weight *= (wrapShading * wrapShading) + 0.2;
+
+                var depthDir = -biasedPosToAdjProbe;//probe - world
+                depthDir = applyQuaternion(depthDir, quaternion);
+                var probeTextureUV : vec2<f32> = textureCoordFromDirection(depthDir.xyz,
+                    adjacentProbeIndex,
+                    irradianceFieldSurface.irradianceTextureWidth,
+                    irradianceFieldSurface.irradianceTextureHeight,
+                    irradianceFieldSurface.irradianceProbeSideLength);
+
+                var filteredDistance : vec2<f32> = 2.0 * textureSampleLevel(irradianceDepthMap, irradianceDepthMapSampler, probeTextureUV,0.0).rg ;
+            
+                var variance = abs((filteredDistance.x * filteredDistance.x) - filteredDistance.y);
+
+                var chebyshevWeight = 1.0;
+                if(biasedPosToAdjProbeDist > filteredDistance.x ) // occluded
+                {
+                    var v = biasedPosToAdjProbeDist - filteredDistance.x ;
+                    chebyshevWeight = variance / (variance + (v * v));
+                    // Increase the contrast in the weight
+                    chebyshevWeight = max((chebyshevWeight * chebyshevWeight * chebyshevWeight), 0.0);
+                }
+
+                weight *= max(0.05, chebyshevWeight);
+                weight = max(0.000001, weight);
+
+                let crushThreshold = 0.2;
+                if (weight < crushThreshold)
+                {
+                    weight *= (weight * weight) * (1.0 / (crushThreshold * crushThreshold));
+                }
+
+                weight *= trilinearWeight;
+                
+                //worldPosToAdjProbe
+                let rotateDir = applyQuaternion(-direction, quaternion);
+                probeTextureUV = textureCoordFromDirection((rotateDir),
+                adjacentProbeIndex,
+                irradianceFieldSurface.irradianceTextureWidth,
+                irradianceFieldSurface.irradianceTextureHeight,
+                irradianceFieldSurface.irradianceProbeSideLength);
+
+                var probeIrradiance: vec3<f32> = textureSampleLevel(irradianceMap, irradianceMapSampler, probeTextureUV ,0.0).xyz;
+
+                var exponent =  irradianceData.ddgiGamma * 0.5;
+                probeIrradiance = pow(probeIrradiance, vec3<f32>(exponent));
+                
+                irradiance += (weight * probeIrradiance);
+                accumulatedWeights += weight;
+            }
+
+            if(accumulatedWeights == 0.0){
+                return vec4<f32>(0.0, 0.0, 0.0,1.0);
+            }
+
+            irradiance *= (1.0 / accumulatedWeights);   
+            irradiance *= irradiance;                   
+
+            irradiance *= 6.2831853071795864;
+            irradiance *= irradianceData.indirectIntensity;
+            return vec4<f32>(irradiance,1.0) ;
+        }
+`;

package/dist/src/assets/shader/lighting/LightingFunction_frag.d.ts

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

package/dist/src/assets/shader/lighting/LightingFunction_frag.js

@@ -0,0 +1,203 @@
+export let LightingFunction_frag = /*wgsl*/ `
+#include "BRDF_frag"
+#include "ClusterLight"
+#include "ShadowMapping_frag"
+
+#if USE_IES_PROFILE
+  #include "IESProfiles_frag"
+#endif
+
+const PI2 = 3.1415926 * 3.1415926 ;
+
+fn sampleLighting(light:LightData,direction:vec3f,iblSpecularResult:vec3f , intensity :f32 , shadow:f32 ) -> vec3f{
+  var ret = vec3f(0.0);
+  var normalDir  = fragData.N;
+  var viewDir    = fragData.V;
+
+  var lightDir   = normalize(-direction.xyz);
+  var halfDir    = normalize(lightDir + viewDir);
+  var reflectDir = normalize(reflect(-viewDir,normalDir));
+
+  var NdotH = max(0.00001,dot(normalDir,halfDir));
+  var NdotL = max(0.00001,dot(normalDir,lightDir));
+  var NdotV = max(0.00001,dot(normalDir,viewDir));
+  var HdotL = max(0.00001,dot(halfDir,lightDir));
+
+  var baseColor = fragData.Albedo.rgb ; 
+  var metallic = fragData.Metallic ;
+  var roughness = fragData.Roughness ;
+
+  var lightColor = getHDRColor( light.lightColor.rgb , light.linear )  ;
+  var att = max(0.0,intensity);
+  
+  var lighting:vec3f = lightContribution(NdotH,NdotL,NdotV,HdotL,fragData.Roughness,fragData.Albedo.rgb / 3.14, metallic ,shadow,fragData.F0,lightColor.rgb);
+
+  lighting = ACESToneMapping(lighting,att);
+  return lighting ;
+}
+
+fn directLighting( light:LightData , iblSpecularResult : vec3f) -> vec3<f32> {
+    var color = vec3<f32>(0.0) ;
+    #if USE_LIGHT
+      var L = normalize(light.direction.xyz) ;
+      #if USE_BRDF
+        var shadow = directShadowVisibility[(light.castShadow)] ;
+        var att = light.intensity;
+        color = sampleLighting(light,L,iblSpecularResult,att, shadow);
+      #endif 
+    #endif 
+    return color;
+}
+
+fn directDulLighting( albedo:vec3<f32>, N:vec3<f32>, V:vec3<f32>,  roughness:f32 , metallic:f32 , light:LightData , shadowBias:f32 ) -> vec3<f32> {
+  var color = vec3<f32>(0.0) ;
+  #if USE_LIGHT
+    var L = -normalize(light.direction.xyz) ;
+    let lightCC = pow( light.lightColor.rgb,vec3<f32>(2.2));
+    var lightColor = getHDRColor( lightCC.rgb , light.linear )  ;
+    var att = light.intensity;
+    if(light.castShadow>=0){
+        #if USE_SHADOWMAPING
+          for (var j: i32 = 0; j < 8; j += 1) {
+              if(j == light.castShadow){
+                att *= directShadowVisibility[j] ; 
+              }
+          }
+        #endif
+    }
+    #if USE_LAMBERT
+      color = vec3<f32>(1.0,1.0,1.0) ;
+    #endif 
+    
+    #if USE_BRDF
+      color = 0.85 * simpleBRDF(albedo,N,V,L,att,lightColor,0.85 * roughness,metallic) ;
+      color += 0.15 * simpleBRDF(albedo,N,V,L,att,lightColor,0.15 * roughness,metallic) ;
+    #endif 
+  #endif 
+  return color;
+}
+
+fn directHairLighting( albedo:vec3<f32>, N:vec3<f32>, V:vec3<f32>,  roughness:f32 , metallic:f32 , light:LightData , shadowBias:f32 ) -> vec3<f32> {
+  var color = vec3<f32>(0.0) ;
+  #if USE_LIGHT
+    var L = -normalize(light.direction.xyz) ;
+    let lightCC = pow( light.lightColor.rgb,vec3<f32>(2.2));
+    var lightColor = getHDRColor( lightCC.rgb , light.linear )  ;
+    var att = light.intensity;
+    if(light.castShadow>=0){
+        #if USE_SHADOWMAPING
+          for (var j: i32 = 0; j < 8; j += 1) {
+              if(j == light.castShadow){
+                att *= directShadowVisibility[j] ; 
+              }
+          }
+        #endif
+    }
+    #if USE_LAMBERT
+      color = vec3<f32>(1.0,1.0,1.0) ;
+    #endif 
+    
+    #if USE_BRDF
+      color = 0.5 * simpleBRDF(albedo,N,V,L,att,lightColor,0.85 ,metallic) ;
+      color += 0.5 * simpleBRDF(albedo,N,V,L,att,lightColor,0.15 ,metallic) ;
+    #endif 
+  #endif 
+  return color;
+}
+
+
+fn pointLighting( WP:vec3<f32>, light:LightData , iblSpecularResult : vec3f ) -> vec3<f32> {
+    var color = vec3<f32>(0.0) ;
+    let lightPos = light.position.xyz;
+    var dir = lightPos.xyz - WP ;
+    let dist = length(dir);
+    if(dist != 0.0){
+      dir *= 1.0 / dist ;
+    }
+    if( abs(dist) < light.range ){
+        var L = dir ;
+        var atten = 1.0 ;
+        atten = 1.0 - smoothstep(0.0,light.range,dist) ;
+        atten *= 1.0 / max(light.radius,0.001)  ;
+
+        var shadow = pointShadows[i32(light.castShadow)] ;
+
+        #if USE_IES_PROFILE
+            atten *= getLightIESProfileAtt(WP,light);
+        #endif
+
+        atten *= sphere_unit(light.range,light.intensity) ;
+
+        color = sampleLighting(light,-L,iblSpecularResult,atten,shadow);
+    } 
+    return color ;
+}
+
+fn pointAtt( WP:vec3<f32>, light:LightData ) -> f32 {
+  var atten = 0.0 ;
+  let lightPos = light.position.xyz;
+  var dir = lightPos.xyz - WP ;
+  let dist = length(dir);
+  if(dist != 0.0){
+    dir *= 1.0 / dist ;
+  }
+  if( abs(dist) < light.range ){
+      var L = dir ;
+      atten = 1.0 - smoothstep(0.0,light.range,dist) ;
+      atten *= 1.0 / max(light.radius,0.001)  ;
+      var shadow = pointShadows[i32(light.castShadow)] ;
+      #if USE_IES_PROFILE
+          atten *= getLightIESProfileAtt(WP,light);
+      #endif
+      atten *= sphere_unit(light.range,light.intensity) ;
+  } 
+  return atten ;
+}
+
+fn getDistanceAtten(  light:LightData , dist : f32 ) -> f32 {
+  return 1.0 - smoothstep(0.0,light.range,dist) ;
+}
+
+fn spotLighting( WP:vec3<f32>, light:LightData , iblSpecularResult : vec3f) -> vec3<f32> {
+    let lightPos = light.position.xyz;
+    var dir = lightPos.xyz - WP ;
+    let dist = length(dir) ;
+    if(dist != 0.0){
+      dir *= 1.0 / dist ;
+    }
+
+    var color = vec3<f32>(0.0) ;
+    if( abs(dist) < light.range * 2.0 ){
+        var L = dir ;
+        let theta = dot(-L, normalize(light.direction));
+        let angle = acos(theta) ;
+        var atten = 1.0 ;
+        var lightColor = light.lightColor.rgb  ;
+
+        atten = 1.0 - smoothstep(0.0,light.range,dist) ;
+        atten *= 1.0 / max(light.radius,0.001) ;
+        if(angle < light.outerCutOff){
+          if(angle > light.innerCutOff){
+            atten *= 1.0 - smoothstep(light.innerCutOff, light.outerCutOff, angle) ;
+          }
+        }else{
+            atten = 0.0 ;
+        }
+
+        var shadow = pointShadows[i32(light.castShadow)] ;
+
+        #if USE_IES_PROFILE
+            atten *= getLightIESProfileAtt(WP,light);
+        #endif
+
+        atten *= sphere_unit(light.range, light.intensity) ;
+
+        color = sampleLighting(light,-L,iblSpecularResult,atten,shadow);
+    }
+    return  color ;
+}
+
+fn sphere_unit( radius:f32 , intensity:f32 ) -> f32 {
+  return intensity / (4.0 * PI2 * radius * radius) ;
+}
+`;

package/dist/src/assets/shader/lighting/UnLit_frag.d.ts

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

package/dist/src/assets/shader/lighting/UnLit_frag.js

@@ -0,0 +1,30 @@
+export let UnLit_frag = `
+    #include "Common_frag"
+    #include "GlobalUniform"
+
+    fn UnLit(){
+        let alpha = ORI_ShadingInput.BaseColor.a;
+        var viewColor = vec4<f32>(ORI_ShadingInput.BaseColor.rgb * alpha, alpha);
+        let finalMatrix = globalUniform.projMat * globalUniform.viewMat;
+        let nMat = mat3x3<f32>(finalMatrix[0].xyz, finalMatrix[1].xyz, finalMatrix[2].xyz);
+        let ORI_NORMALMATRIX = transpose(inverse(nMat));
+        var vNormal = normalize(ORI_NORMALMATRIX * (ORI_VertexVarying.vWorldNormal));
+        let gBuffer = packNHMDGBuffer(
+            ORI_VertexVarying.fragCoord.z,
+            vec3f(0.0),
+            viewColor.rgb,
+            vec3f(1.0,0.0,0.0),
+            vNormal,
+            alpha
+        );
+
+        #if USE_CASTREFLECTION
+            ORI_FragmentOutput.gBuffer = gBuffer;
+        #else
+            ORI_FragmentOutput.gBuffer = gBuffer;
+            ORI_FragmentOutput.color = viewColor;
+        #endif
+    }
+
+    fn debugFragmentOut(){}
+`;

package/dist/src/assets/shader/materials/ColorLitShader.d.ts

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

package/dist/src/assets/shader/materials/ColorLitShader.js

@@ -0,0 +1,22 @@
+export let ColorLitShader = /*wgsl */ `
+        #include "Common_vert"
+        #include "Common_frag"
+        #include "BxDF_frag"
+
+        fn vert(inputData:VertexAttributes) -> VertexOutput {
+            ORI_Vert(inputData);
+            return ORI_VertexOut;
+        }
+
+        fn frag(){
+            ORI_ShadingInput.BaseColor = materialUniform.baseColor ;
+            ORI_ShadingInput.Roughness = materialUniform.roughness  ;
+            ORI_ShadingInput.Metallic = materialUniform.metallic ;
+            ORI_ShadingInput.Specular = 0.5 ;
+            ORI_ShadingInput.AmbientOcclusion = 1.0 ;
+            ORI_ShadingInput.EmissiveColor = vec4<f32>(0.0);
+            ORI_ShadingInput.Normal = ORI_VertexVarying.vWorldNormal.rgb ;
+            useShadow();
+            BxDFShading();
+        }
+`;

package/dist/src/assets/shader/materials/GIProbeShader.d.ts

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

package/dist/src/assets/shader/materials/GIProbeShader.js

@@ -0,0 +1,34 @@
+export let GIProbeShader = /*wgsl */ `
+    #include "Common_vert"
+    #include "Common_frag"
+    #include "UnLit_frag"
+    #include "Irradiance_frag"
+    #include "MathShader"
+
+    struct MaterialUniform {
+      probeUniform:vec4<f32>,
+    };
+
+    @groups(2) @binding(0) var<uniform> materialUniform: MaterialUniform;
+
+    var<private> probeID: i32;
+    var<private> debugType: i32;
+
+    fn vert(inputData: VertexAttributes) -> VertexOutput {
+        ORI_Vert(inputData);
+        return ORI_VertexOut;
+    }
+
+    fn frag(){
+        probeID = i32(materialUniform.probeUniform.x);
+        debugType = i32(materialUniform.probeUniform.y);
+        if(debugType == 0){
+            ORI_ShadingInput.BaseColor = debugProbe(probeID);
+        }else if(debugType == 1){
+            ORI_ShadingInput.BaseColor = getIrradiance();
+        }else if(debugType == 2){
+            ORI_ShadingInput.BaseColor = debugProbeDepth(probeID);
+        }
+        UnLit();
+    }
+`;

package/dist/src/assets/shader/materials/GlassShader.d.ts

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

package/dist/src/assets/shader/materials/GlassShader.js

@@ -0,0 +1,26 @@
+export let GlassShader = /*wgsl */ `
+    #include "Common_vert"
+    #include "Common_frag"
+    #include "UnLit_frag"
+    #include "UnLitMaterialUniform_frag"
+
+    @group(1) @binding(auto) var splitTexture_MapSampler: sampler;
+    @group(1) @binding(auto) var splitTexture_Map: texture_2d<f32>;
+
+    fn vert(inputData: VertexAttributes) -> VertexOutput {
+        ORI_Vert(inputData);
+        return ORI_VertexOut;
+    }
+
+    fn frag(){
+        var screenUV = ORI_VertexVarying.fragPosition.xy / ORI_VertexVarying.fragPosition.w;
+        screenUV = (screenUV.xy + 1.0) * 0.5;
+        screenUV.y = 1.0 - screenUV.y;
+
+        screenUV.x = clamp(sin(screenUV.x * 1.0),0.0,1.0) ;
+        screenUV.y = clamp(sin(screenUV.y * 1.0),0.0,1.0) ;
+        let frameMap = textureSample(splitTexture_Map,splitTexture_MapSampler,screenUV);
+        ORI_ShadingInput.BaseColor = vec4<f32>( frameMap.rgb , 1.0) ;
+        UnLit();
+    }
+`;

package/dist/src/assets/shader/materials/Hair_shader.d.ts

@@ -0,0 +1,2 @@
+export declare let Hair_shader_op: string;
+export declare let Hair_shader_tr: string;