npm - @onerjs/core - Versions diffs - 8.56.4 → 9.0.0 - Mend

@onerjs/core 8.56.4 → 9.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (482) hide show

package/ShadersWGSL/meshBlending.fragment.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"meshBlending.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/meshBlending.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqjBd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"meshBlendingPixelShader\";\nconst shader = `#define DISABLE_UNIFORMITY_ANALYSIS\nvarying vUV: vec2f;var textureSampler: texture_2d<f32>;var meshBlendTagSampler: texture_2d<u32>;var meshBlendDepthSampler: texture_2d<f32>;\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nvar meshBlendBaseColorSampler: texture_2d<f32>;\n#endif\nvar meshBlendBlueNoiseSampler: texture_2d<f32>;uniform projection: mat4x4f;uniform inverseProjection: mat4x4f;uniform inverseView: mat4x4f;uniform blendWorldRadii: vec4f;uniform minimumProjectedRadii: vec4f;uniform meshBlendIsOrthographic: f32;uniform slopeFactor: f32;\n#ifndef MESH_BLEND_DIRECTION_COUNT\n#define MESH_BLEND_DIRECTION_COUNT 3\n#define MESH_BLEND_RADIAL_SAMPLE_COUNT 3\n#define MESH_BLEND_DIRECTION_REFINEMENT_SAMPLE_COUNT 2\n#define MESH_BLEND_DIRECTION_REFINEMENT_STEP_COUNT 4\n#define MESH_BLEND_EXACT_EDGE_SAMPLE_COUNT 8\n#define MESH_BLEND_RADIUS_SCALE 0.9\n#define MESH_BLEND_JITTER_FACTOR 0.5\n#define MESH_BLEND_COLOR_INTERPOLATION_OKLAB\n#endif\n#define MESH_BLEND_TWO_PI 6.283185307179586\n#define MESH_BLEND_EPSILON 0.00001\n#define MESH_BLEND_DIRECTION_REFINEMENT_SECTOR_SCALE 0.2\n#define MESH_BLEND_TINY_OBJECT_PROBE_COUNT 8\n#define MESH_BLEND_MIN_SLOPE_SCALE 0.25\n#define MESH_BLEND_BOUNDARY_SEPARATION_FACTOR 0.75\n#define MESH_BLEND_BOUNDARY_PIXEL_TOLERANCE 3.0\n#define MESH_BLEND_FOREGROUND_DEPTH_FACTOR 0.35\n#define MESH_BLEND_FOREGROUND_LATERAL_FACTOR 2.0\n#define MESH_BLEND_TARGET_SPAN_FACTOR 1.5\n#define MESH_BLEND_TOTAL_SPAN_FACTOR 2.5\n#define MESH_BLEND_NEAR_EDGE_TARGET_WEIGHT 0.35\n#define MESH_BLEND_NEAR_SEAM_MAX_DISTANCE 1.25\n#define MESH_BLEND_NEAR_SEAM_COLOR_DELTA 0.02\n#define MESH_BLEND_BASE_LUMINANCE_EPSILON 0.00001\n#define MESH_BLEND_TARGET_DARKER_RATIO 0.65\n#define MESH_BLEND_TARGET_NON_DARK_RATIO 0.9\n#define MESH_BLEND_SHADOW_DIFFERENCE_LOW 0.15\n#define MESH_BLEND_SHADOW_DIFFERENCE_HIGH 0.5\n#define MESH_BLEND_SHADOW_MIN_ATTENUATION 0.25\n#define MESH_BLEND_REJECTION_NONE 0\n#define MESH_BLEND_REJECTION_NO_CANDIDATE 1\n#define MESH_BLEND_REJECTION_NO_CONTINUATION 2\n#define MESH_BLEND_REJECTION_INVALID_DEPTH 3\n#define MESH_BLEND_REJECTION_DEPTH_SEPARATION 4\n#define MESH_BLEND_REJECTION_FOREGROUND_BACKGROUND 5\n#define MESH_BLEND_REJECTION_PHYSICAL_SPAN 6\n#define MESH_BLEND_REJECTION_CONTACT_ANGLE 7\nstruct MeshBlendTag {groupId: u32,\nradiusClass: u32,};struct MeshBlendCandidate {targetGroupId: u32,\nradiusClass: u32,\ndirection: vec2f,\ndistancePixels: f32,\nsearchRadiusPixels: f32,\nscore: f32,\nvalid: bool,};struct MeshBlendResult {candidate: MeshBlendCandidate,\ntargetPixel: vec2i,\ntargetFarPixel: vec2i,\ncurrentViewPosition: vec3f,\neffectiveRadiusPixels: f32,\nfade: f32,\ntinyObjectRadiusRatio: f32,\nrejectionReason: i32,\nstageReached: i32,\nvalid: bool,\ncontinuationFound: bool,\nusedFallback: bool,\ntinyObjectRadiusReduced: bool,};struct MeshBlendTargetColorSamples {fartherColor: vec4f,\nboundaryPlusOneColor: vec4f,\nboundaryPlusTwoColor: vec4f,\nconservativeNearColor: vec4f,\ntargetColor: vec4f,\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nfartherBaseColor: vec3f,\nconservativeNearBaseColor: vec3f,\n#endif\nonePixelEdge: bool,};struct MeshBlendColorEvaluation {samples: MeshBlendTargetColorSamples,\ncurrentColor: vec4f,\nblendedColor: vec4f,\n#ifdef MESH_BLEND_DEBUG_WORLD_POSITION\nworldPosition: vec3f,\n#endif\nshadowAttenuation: f32,\nadjustedFade: f32,\nnearSeamCorrected: bool,};fn clampPixel(pixel: vec2i,renderSize: vec2i)->vec2i {return clamp(pixel,vec2i(0),renderSize-vec2i(1));}\nfn isPixelInBounds(pixel: vec2i,renderSize: vec2i)->bool {return pixel.x>=0 && pixel.y>=0 && pixel.x<renderSize.x && pixel.y<renderSize.y;}\nfn pixelToUv(pixel: vec2i,renderSize: vec2i)->vec2f {return (vec2f(clampPixel(pixel,renderSize))+vec2f(0.5))/vec2f(renderSize);}\nfn loadMeshBlendTag(pixel: vec2i,renderSize: vec2i)->MeshBlendTag {let packedTag: u32=textureLoad(meshBlendTagSampler,clampPixel(pixel,renderSize),0).r;var tag: MeshBlendTag;tag.groupId=packedTag & 0x3fu;tag.radiusClass=packedTag>>6u;return tag;}\nfn loadMeshBlendDepth(pixel: vec2i,renderSize: vec2i)->f32 {return textureLoad(meshBlendDepthSampler,clampPixel(pixel,renderSize),0).r;}\nfn classValue(values: vec4f,index: u32)->f32 {if (index==0u) {return values.x;}\nif (index==1u) {return values.y;}\nif (index==2u) {return values.z;}\nreturn values.w;}\nfn meshBlendDepthToNdc(depth: f32)->f32 {\n#ifdef MESH_BLEND_DEPTH_SCREEN\n#ifdef IS_NDC_HALF_ZRANGE\nreturn depth;\n#else\nreturn depth*2.0-1.0;\n#endif\n#else\nlet projectedDepth: vec4f=uniforms.projection*vec4f(0.0,0.0,depth,1.0);return projectedDepth.z/projectedDepth.w;\n#endif\n}\nfn reconstructMeshBlendViewPosition(pixel: vec2i,renderSize: vec2i,depth: f32)->vec3f {let ndcXY: vec2f=pixelToUv(pixel,renderSize)*2.0-1.0;let viewPosition: vec4f=uniforms.inverseProjection*vec4f(ndcXY,meshBlendDepthToNdc(depth),1.0);return viewPosition.xyz/viewPosition.w;}\nfn reconstructMeshBlendWorldPosition(viewPosition: vec3f)->vec3f {return (uniforms.inverseView*vec4f(viewPosition,1.0)).xyz;}\nfn isFiniteMeshBlendValue(value: f32)->bool {return (bitcast<u32>(value) & 0x7f800000u) != 0x7f800000u;}\nfn isValidMeshBlendPosition(position: vec3f)->bool {return isFiniteMeshBlendValue(position.x) && isFiniteMeshBlendValue(position.y) && isFiniteMeshBlendValue(position.z);}\nfn meshBlendProjectionScale(renderHeight: f32)->f32 {return max(0.5*renderHeight*abs(uniforms.projection[1][1]),MESH_BLEND_EPSILON);}\nfn searchRadiusForClass(radiusClass: u32,viewDepth: f32,renderHeight: f32)->f32 {let projectionScale: f32=meshBlendProjectionScale(renderHeight);var projectedWorldRadius: f32=classValue(uniforms.blendWorldRadii,radiusClass)*projectionScale;if (uniforms.meshBlendIsOrthographic<0.5) {projectedWorldRadius/=max(viewDepth,MESH_BLEND_EPSILON);}\nlet scaledRadius: f32=max(projectedWorldRadius,classValue(uniforms.minimumProjectedRadii,radiusClass))*MESH_BLEND_RADIUS_SCALE;return select(0.0,max(1.0,scaledRadius),scaledRadius>0.0);}\nfn worldUnitsPerPixel(viewDepth: f32,renderHeight: f32)->f32 {let unitsPerPixel: f32=1.0/meshBlendProjectionScale(renderHeight);if (uniforms.meshBlendIsOrthographic>0.5) {return unitsPerPixel;}\nreturn unitsPerPixel*max(viewDepth,MESH_BLEND_EPSILON);}\nfn calculateSlopeScale(oppositeFacing: f32)->f32 {if (uniforms.slopeFactor<=1.0) {return 1.0;}\nreturn MESH_BLEND_MIN_SLOPE_SCALE +\n(1.0-MESH_BLEND_MIN_SLOPE_SCALE)*pow(clamp(oppositeFacing,0.0,1.0),uniforms.slopeFactor-1.0);}\nfn loadStableBlueNoise(pixel: vec2i)->vec2f {let noiseSize: vec2i=vec2i(textureDimensions(meshBlendBlueNoiseSampler,0));let wrappedPixel: vec2i=vec2i(pixel.x % noiseSize.x,pixel.y % noiseSize.y);return textureLoad(meshBlendBlueNoiseSampler,wrappedPixel,0).rg;}\nfn directionAt(index: i32,rotation: f32,sectorAngle: f32,direction0: vec2f,direction1: vec2f,direction2: vec2f)->vec2f {\n#if MESH_BLEND_DIRECTION_COUNT==3\nif (index==0) {return direction0;}\nif (index==1) {return direction1;}\nreturn direction2;\n#else\nlet angle: f32=rotation+sectorAngle*f32(index);return vec2f(cos(angle),sin(angle));\n#endif\n}\nfn invalidCandidate()->MeshBlendCandidate {var candidate: MeshBlendCandidate;candidate.targetGroupId=0u;candidate.radiusClass=0u;candidate.direction=vec2f(0.0);candidate.distancePixels=0.0;candidate.searchRadiusPixels=0.0;candidate.score=-1.0;candidate.valid=false;return candidate;}\nfn invalidBlendResult()->MeshBlendResult {var result: MeshBlendResult;result.candidate=invalidCandidate();result.targetPixel=vec2i(0);result.targetFarPixel=vec2i(0);result.currentViewPosition=vec3f(0.0);result.effectiveRadiusPixels=0.0;result.fade=0.0;result.tinyObjectRadiusRatio=1.0;result.rejectionReason=MESH_BLEND_REJECTION_NO_CANDIDATE;result.stageReached=1;result.valid=false;result.continuationFound=false;result.usedFallback=false;result.tinyObjectRadiusReduced=false;return result;}\nfn findInitialCandidate(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\ncurrentSearchRadius: f32,\nviewDepth: f32,\nignoredGroupId: u32,\nrandomValues: vec2f,\nrotation: f32,\nsectorAngle: f32,\ndirection0: vec2f,\ndirection1: vec2f,\ndirection2: vec2f\n)->MeshBlendCandidate {var best: MeshBlendCandidate=invalidCandidate();let radialJitter: f32=mix(0.5,randomValues.y,MESH_BLEND_JITTER_FACTOR);for (var radialIndex: i32=0; radialIndex<MESH_BLEND_RADIAL_SAMPLE_COUNT; radialIndex++) {let normalizedDistance: f32=(f32(radialIndex)+radialJitter)/f32(MESH_BLEND_RADIAL_SAMPLE_COUNT);let distancePixels: f32=max(1.0,ceil(normalizedDistance*normalizedDistance*normalizedDistance*currentSearchRadius));for (var directionIndex: i32=0; directionIndex<MESH_BLEND_DIRECTION_COUNT; directionIndex++) {let direction: vec2f=directionAt(directionIndex,rotation,sectorAngle,direction0,direction1,direction2);let samplePixel: vec2i=pixel+vec2i(round(direction*distancePixels));let candidateTag: MeshBlendTag=loadMeshBlendTag(samplePixel,renderSize);if (candidateTag.groupId==0u || candidateTag.groupId==currentTag.groupId || candidateTag.groupId==ignoredGroupId) {continue;}\nlet seamRadiusClass: u32=min(currentTag.radiusClass,candidateTag.radiusClass);let candidateSearchRadius: f32=searchRadiusForClass(seamRadiusClass,viewDepth,f32(renderSize.y));if (distancePixels>candidateSearchRadius) {continue;}\nlet score: f32=1.0-clamp(distancePixels/max(candidateSearchRadius,MESH_BLEND_EPSILON),0.0,1.0);if (score>best.score) {best.targetGroupId=candidateTag.groupId;best.radiusClass=seamRadiusClass;best.direction=direction;best.distancePixels=distancePixels;best.searchRadiusPixels=candidateSearchRadius;best.score=score;best.valid=true;}}\nif (best.valid) {break;}}\nreturn best;}\nfn refineCandidateDirection(pixel: vec2i,renderSize: vec2i,candidate: MeshBlendCandidate,randomValues: vec2f)->MeshBlendCandidate {var refinedCandidate: MeshBlendCandidate=candidate;if (refinedCandidate.distancePixels<=2.0) {return refinedCandidate;}\nlet centerAngle: f32=atan2(refinedCandidate.direction.y,refinedCandidate.direction.x);let angularHalfWidth: f32=(MESH_BLEND_TWO_PI/f32(MESH_BLEND_DIRECTION_COUNT))*MESH_BLEND_DIRECTION_REFINEMENT_SECTOR_SCALE;let stepSize: f32=max(1.0,refinedCandidate.distancePixels/f32(MESH_BLEND_DIRECTION_REFINEMENT_STEP_COUNT+1));for (var sampleIndex: i32=0; sampleIndex<MESH_BLEND_DIRECTION_REFINEMENT_SAMPLE_COUNT; sampleIndex++) {let sampleRandom: f32=fract(randomValues.y+randomValues.x*0.754877666+f32(sampleIndex)*0.618033989);let angle: f32=centerAngle+mix(-angularHalfWidth,angularHalfWidth,sampleRandom);let direction: vec2f=vec2f(cos(angle),sin(angle));var testDistance: f32=refinedCandidate.distancePixels-stepSize;for (var stepIndex: i32=0; stepIndex<MESH_BLEND_DIRECTION_REFINEMENT_STEP_COUNT; stepIndex++) {if (testDistance<=0.0) {break;}\nlet samplePixel: vec2i=pixel+vec2i(round(direction*testDistance));let sampleTag: MeshBlendTag=loadMeshBlendTag(samplePixel,renderSize);if (sampleTag.groupId != refinedCandidate.targetGroupId) {break;}\nrefinedCandidate.direction=direction;refinedCandidate.distancePixels=testDistance;testDistance-=stepSize;}}\nreturn refinedCandidate;}\nfn refineExactBoundary(pixel: vec2i,renderSize: vec2i,candidate: MeshBlendCandidate)->MeshBlendCandidate {var refinedCandidate: MeshBlendCandidate=candidate;var distancePixels: f32=refinedCandidate.distancePixels;for (var sampleIndex: i32=0; sampleIndex<MESH_BLEND_EXACT_EDGE_SAMPLE_COUNT; sampleIndex++) {distancePixels-=1.0;if (distancePixels<=0.0) {break;}\nlet samplePixel: vec2i=pixel+vec2i(round(refinedCandidate.direction*distancePixels));let sampleTag: MeshBlendTag=loadMeshBlendTag(samplePixel,renderSize);if (sampleTag.groupId != refinedCandidate.targetGroupId) {break;}\nrefinedCandidate.distancePixels=distancePixels;}\nreturn refinedCandidate;}\nfn hasTargetContinuation(\npixel: vec2i,\nrenderSize: vec2i,\ncandidate: MeshBlendCandidate,\ncontinuationPixel: ptr<function,vec2i>\n)->bool {let continuationDistance: f32=max(candidate.distancePixels*2.0,candidate.distancePixels+1.0);*continuationPixel=pixel+vec2i(round(candidate.direction*continuationDistance));if (!isPixelInBounds(*continuationPixel,renderSize)) {return false;}\nreturn loadMeshBlendTag(*continuationPixel,renderSize).groupId==candidate.targetGroupId;}\nfn applyTargetRadiusClass(\ntargetPixel: vec2i,\nrenderSize: vec2i,\nviewDepth: f32,\ncandidate: ptr<function,MeshBlendCandidate>\n)->bool {let targetTag: MeshBlendTag=loadMeshBlendTag(targetPixel,renderSize);(*candidate).radiusClass=min((*candidate).radiusClass,targetTag.radiusClass);(*candidate).searchRadiusPixels=min(\n(*candidate).searchRadiusPixels,\nsearchRadiusForClass((*candidate).radiusClass,viewDepth,f32(renderSize.y))\n);return (*candidate).distancePixels<=(*candidate).searchRadiusPixels;}\n#ifdef MESH_BLEND_FOUR_NEIGHBOR_FALLBACK\nfn findImmediateNeighborCandidate(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\nviewDepth: f32,\nignoredGroupId: u32,\npreferredGroupId: u32\n)->MeshBlendCandidate {var best: MeshBlendCandidate=invalidCandidate();for (var neighborIndex: i32=0; neighborIndex<4; neighborIndex++) {var offset: vec2i;if (neighborIndex==0) {offset=vec2i(1,0);} else if (neighborIndex==1) {offset=vec2i(-1,0);} else if (neighborIndex==2) {offset=vec2i(0,1);} else {offset=vec2i(0,-1);}\nlet neighborTag: MeshBlendTag=loadMeshBlendTag(pixel+offset,renderSize);if (neighborTag.groupId==0u || neighborTag.groupId==currentTag.groupId || neighborTag.groupId==ignoredGroupId) {continue;}\nlet seamRadiusClass: u32=min(currentTag.radiusClass,neighborTag.radiusClass);let candidateSearchRadius: f32=searchRadiusForClass(seamRadiusClass,viewDepth,f32(renderSize.y));if (candidateSearchRadius<1.0) {continue;}\nvar score: f32=1.0-1.0/max(candidateSearchRadius,1.0);if (neighborTag.groupId==preferredGroupId) {score+=1.0;}\nif (score>best.score) {best.targetGroupId=neighborTag.groupId;best.radiusClass=seamRadiusClass;best.direction=vec2f(offset);best.distancePixels=1.0;best.searchRadiusPixels=candidateSearchRadius;best.score=score;best.valid=true;}}\nreturn best;}\n#endif\n#ifdef MESH_BLEND_TINY_OBJECT_SAFEGUARD\nfn reduceRadiusForTinyObject(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\ncandidate: MeshBlendCandidate,\nradiusReduced: ptr<function,bool>\n)->f32 {var measuredThickness: f32=candidate.searchRadiusPixels;var foundOppositeBoundary: bool=false;for (var probeIndex: i32=1; probeIndex<=MESH_BLEND_TINY_OBJECT_PROBE_COUNT; probeIndex++) {let probeDistance: f32=max(1.0,candidate.searchRadiusPixels*f32(probeIndex)/f32(MESH_BLEND_TINY_OBJECT_PROBE_COUNT));let oppositeTag: MeshBlendTag=loadMeshBlendTag(pixel-vec2i(round(candidate.direction*probeDistance)),renderSize);if (oppositeTag.groupId != currentTag.groupId) {measuredThickness=probeDistance;foundOppositeBoundary=true;break;}}\nvar outsideDirectionCount: i32=0;for (var neighborIndex: i32=0; neighborIndex<4; neighborIndex++) {var direction: vec2f;if (neighborIndex==0) {direction=vec2f(1.0,0.0);} else if (neighborIndex==1) {direction=vec2f(-1.0,0.0);} else if (neighborIndex==2) {direction=vec2f(0.0,1.0);} else {direction=vec2f(0.0,-1.0);}\nlet radiusTag: MeshBlendTag=loadMeshBlendTag(pixel+vec2i(round(direction*candidate.searchRadiusPixels)),renderSize);if (radiusTag.groupId != currentTag.groupId) {outsideDirectionCount++;}}\n*radiusReduced=foundOppositeBoundary && outsideDirectionCount>=3;if (!*radiusReduced) {return candidate.searchRadiusPixels;}\nlet thicknessRadius: f32=max(1.0,measuredThickness*1.25);return max(candidate.distancePixels,min(candidate.searchRadiusPixels,thicknessRadius));}\n#endif\nfn validateMeshBlendContact(\npixelA: vec2i,\npixelE: vec2i,\npixelB: vec2i,\npixelC: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\ncandidate: MeshBlendCandidate,\nallowMissingContinuation: bool,\nnarrowedSearchRadius: ptr<function,f32>,\ncurrentViewPosition: ptr<function,vec3f>\n)->i32 {*currentViewPosition=vec3f(0.0);let tagE: MeshBlendTag=loadMeshBlendTag(pixelE,renderSize);let tagB: MeshBlendTag=loadMeshBlendTag(pixelB,renderSize);let tagC: MeshBlendTag=loadMeshBlendTag(pixelC,renderSize);if (\ntagE.groupId != currentTag.groupId ||\ntagB.groupId != candidate.targetGroupId ||\n(!allowMissingContinuation && tagC.groupId != candidate.targetGroupId)\n) {return MESH_BLEND_REJECTION_NO_CONTINUATION;}\nlet depthA: f32=loadMeshBlendDepth(pixelA,renderSize);let depthE: f32=loadMeshBlendDepth(pixelE,renderSize);let depthB: f32=loadMeshBlendDepth(pixelB,renderSize);let depthC: f32=loadMeshBlendDepth(pixelC,renderSize);let positionA: vec3f=reconstructMeshBlendViewPosition(pixelA,renderSize,depthA);let positionE: vec3f=reconstructMeshBlendViewPosition(pixelE,renderSize,depthE);let positionB: vec3f=reconstructMeshBlendViewPosition(pixelB,renderSize,depthB);let positionC: vec3f=reconstructMeshBlendViewPosition(pixelC,renderSize,depthC);if (!isValidMeshBlendPosition(positionA) || !isValidMeshBlendPosition(positionE) || !isValidMeshBlendPosition(positionB) || !isValidMeshBlendPosition(positionC)) {return MESH_BLEND_REJECTION_INVALID_DEPTH;}\n*currentViewPosition=positionA;let viewDepth: f32=abs(positionA.z);let unitsPerPixel: f32=worldUnitsPerPixel(viewDepth,f32(renderSize.y));let effectiveWorldRadius: f32=candidate.searchRadiusPixels*unitsPerPixel;let pixelTolerance: f32=unitsPerPixel*MESH_BLEND_BOUNDARY_PIXEL_TOLERANCE;let boundarySpan: vec3f=positionB-positionE;let boundarySeparation: f32=length(boundarySpan);if (boundarySeparation>effectiveWorldRadius*MESH_BLEND_BOUNDARY_SEPARATION_FACTOR+pixelTolerance) {return MESH_BLEND_REJECTION_DEPTH_SEPARATION;}\nlet boundaryDepthDelta: f32=abs(abs(positionB.z)-abs(positionE.z));let boundaryLateralSpan: f32=length(boundarySpan.xy);if (\nboundaryDepthDelta>max(effectiveWorldRadius*MESH_BLEND_FOREGROUND_DEPTH_FACTOR,pixelTolerance) &&\nboundaryDepthDelta>boundaryLateralSpan*MESH_BLEND_FOREGROUND_LATERAL_FACTOR\n) {return MESH_BLEND_REJECTION_FOREGROUND_BACKGROUND;}\nlet targetSpan: f32=distance(positionB,positionC);let totalSpan: f32=distance(positionA,positionC);if (\ntargetSpan>effectiveWorldRadius*MESH_BLEND_TARGET_SPAN_FACTOR+pixelTolerance ||\ntotalSpan>effectiveWorldRadius*MESH_BLEND_TOTAL_SPAN_FACTOR+pixelTolerance\n) {return MESH_BLEND_REJECTION_PHYSICAL_SPAN;}\nlet currentDirection: vec3f=positionA-positionB;let targetDirection: vec3f=positionC-positionB;let currentLength: f32=length(currentDirection);let targetLength: f32=length(targetDirection);var oppositeFacing: f32=1.0;if (currentLength>MESH_BLEND_EPSILON && targetLength>MESH_BLEND_EPSILON) {oppositeFacing=-dot(currentDirection/currentLength,targetDirection/targetLength);}\n*narrowedSearchRadius=candidate.searchRadiusPixels*calculateSlopeScale(oppositeFacing);if (candidate.distancePixels>*narrowedSearchRadius) {return MESH_BLEND_REJECTION_CONTACT_ANGLE;}\nreturn MESH_BLEND_REJECTION_NONE;}\nfn calculateMeshBlendFade(distancePixels: f32,searchRadiusPixels: f32)->f32 {let boundaryDistance: f32=max(distancePixels-0.5,0.0);let normalizedDistance: f32=clamp(boundaryDistance/max(searchRadiusPixels,MESH_BLEND_EPSILON),0.0,1.0);let inverseDistance: f32=1.0-normalizedDistance;let fade: f32=mix(inverseDistance*inverseDistance,inverseDistance,clamp(inverseDistance-0.75,0.0,1.0));return fade*0.5;}\nfn evaluateMeshBlend(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\ncurrentSearchRadius: f32,\nviewDepth: f32,\nignoredGroupId: u32,\nrandomValues: vec2f,\nrotation: f32,\nsectorAngle: f32,\ndirection0: vec2f,\ndirection1: vec2f,\ndirection2: vec2f\n)->MeshBlendResult {var result: MeshBlendResult=invalidBlendResult();var candidate: MeshBlendCandidate=findInitialCandidate(\npixel,\nrenderSize,\ncurrentTag,\ncurrentSearchRadius,\nviewDepth,\nignoredGroupId,\nrandomValues,\nrotation,\nsectorAngle,\ndirection0,\ndirection1,\ndirection2\n);result.candidate=candidate;if (!candidate.valid) {return result;}\nresult.stageReached=2;candidate=refineCandidateDirection(pixel,renderSize,candidate,randomValues);candidate=refineExactBoundary(pixel,renderSize,candidate);result.candidate=candidate;result.stageReached=3;let refinedTargetPixel: vec2i=clampPixel(pixel+vec2i(round(candidate.direction*candidate.distancePixels)),renderSize);if (!applyTargetRadiusClass(refinedTargetPixel,renderSize,viewDepth,&candidate)) {result.candidate=candidate;result.rejectionReason=MESH_BLEND_REJECTION_PHYSICAL_SPAN;return result;}\nresult.candidate=candidate;var continuationPixel: vec2i;var continuationFound: bool=hasTargetContinuation(pixel,renderSize,candidate,&continuationPixel);if (!continuationFound) {\n#ifdef MESH_BLEND_FOUR_NEIGHBOR_FALLBACK\nlet fallbackCandidate: MeshBlendCandidate=findImmediateNeighborCandidate(\npixel,\nrenderSize,\ncurrentTag,\nviewDepth,\nignoredGroupId,\ncandidate.targetGroupId\n);if (!fallbackCandidate.valid) {result.rejectionReason=MESH_BLEND_REJECTION_NO_CONTINUATION;return result;}\ncandidate=fallbackCandidate;result.candidate=candidate;result.usedFallback=true;continuationFound=hasTargetContinuation(pixel,renderSize,candidate,&continuationPixel);\n#else\nresult.rejectionReason=MESH_BLEND_REJECTION_NO_CONTINUATION;return result;\n#endif\n}\nresult.continuationFound=continuationFound;result.stageReached=4;if (continuationFound && !applyTargetRadiusClass(continuationPixel,renderSize,viewDepth,&candidate)) {result.candidate=candidate;result.rejectionReason=MESH_BLEND_REJECTION_PHYSICAL_SPAN;return result;}\nresult.candidate=candidate;let originalSearchRadius: f32=candidate.searchRadiusPixels;\n#ifdef MESH_BLEND_TINY_OBJECT_SAFEGUARD\nvar tinyObjectRadiusReduced: bool=false;candidate.searchRadiusPixels=reduceRadiusForTinyObject(pixel,renderSize,currentTag,candidate,&tinyObjectRadiusReduced);result.tinyObjectRadiusReduced=tinyObjectRadiusReduced;result.stageReached=5;\n#endif\nresult.candidate=candidate;result.effectiveRadiusPixels=candidate.searchRadiusPixels;result.tinyObjectRadiusRatio=candidate.searchRadiusPixels/max(originalSearchRadius,MESH_BLEND_EPSILON);let pixelB: vec2i=clampPixel(pixel+vec2i(round(candidate.direction*candidate.distancePixels)),renderSize);let pixelE: vec2i=clampPixel(pixel+vec2i(round(candidate.direction*max(candidate.distancePixels-2.0,0.0))),renderSize);var pixelC: vec2i=pixelB;if (continuationFound) {pixelC=continuationPixel;}\nvar narrowedSearchRadius: f32=candidate.searchRadiusPixels;var currentViewPosition: vec3f=vec3f(0.0);result.rejectionReason=validateMeshBlendContact(\npixel,\npixelE,\npixelB,\npixelC,\nrenderSize,\ncurrentTag,\ncandidate,\nresult.usedFallback && !continuationFound,\n&narrowedSearchRadius,\n&currentViewPosition\n);result.currentViewPosition=currentViewPosition;result.stageReached=6;result.effectiveRadiusPixels=narrowedSearchRadius;if (result.rejectionReason != MESH_BLEND_REJECTION_NONE) {return result;}\nresult.fade=calculateMeshBlendFade(candidate.distancePixels,narrowedSearchRadius);if (result.fade<=0.0) {result.rejectionReason=MESH_BLEND_REJECTION_PHYSICAL_SPAN;return result;}\nresult.targetPixel=pixelB;result.targetFarPixel=pixelB;if (continuationFound) {result.targetFarPixel=continuationPixel;}\nresult.stageReached=7;result.valid=true;return result;}\nfn meshBlendLinearToSrgbChannel(value: f32)->f32 {if (value<=0.0031308) {return value*12.92;}\nreturn 1.055*pow(value,1.0/2.4)-0.055;}\nfn meshBlendSrgbToLinearChannel(value: f32)->f32 {if (value<=0.04045) {return value/12.92;}\nreturn pow((value+0.055)/1.055,2.4);}\nfn meshBlendLinearToSrgb(color: vec3f)->vec3f {return vec3f(\nmeshBlendLinearToSrgbChannel(color.r),\nmeshBlendLinearToSrgbChannel(color.g),\nmeshBlendLinearToSrgbChannel(color.b)\n);}\nfn meshBlendSrgbToLinear(color: vec3f)->vec3f {return vec3f(\nmeshBlendSrgbToLinearChannel(color.r),\nmeshBlendSrgbToLinearChannel(color.g),\nmeshBlendSrgbToLinearChannel(color.b)\n);}\nfn meshBlendSignedCubeRoot(value: f32)->f32 {return sign(value)*pow(abs(value),1.0/3.0);}\nfn meshBlendLinearSrgbToOklab(color: vec3f)->vec3f {let longResponse: f32=0.4122214708*color.r+0.5363325363*color.g+0.0514459929*color.b;let mediumResponse: f32=0.2119034982*color.r+0.6806995451*color.g+0.1073969566*color.b;let shortResponse: f32=0.0883024619*color.r+0.2817188376*color.g+0.6299787005*color.b;let longRoot: f32=meshBlendSignedCubeRoot(longResponse);let mediumRoot: f32=meshBlendSignedCubeRoot(mediumResponse);let shortRoot: f32=meshBlendSignedCubeRoot(shortResponse);return vec3f(\n0.2104542553*longRoot+0.7936177850*mediumRoot-0.0040720468*shortRoot,\n1.9779984951*longRoot-2.4285922050*mediumRoot+0.4505937099*shortRoot,\n0.0259040371*longRoot+0.7827717662*mediumRoot-0.8086757660*shortRoot\n);}\nfn meshBlendOklabToLinearSrgb(color: vec3f)->vec3f {let longRoot: f32=color.x+0.3963377774*color.y+0.2158037573*color.z;let mediumRoot: f32=color.x-0.1055613458*color.y-0.0638541728*color.z;let shortRoot: f32=color.x-0.0894841775*color.y-1.2914855480*color.z;let longResponse: f32=longRoot*longRoot*longRoot;let mediumResponse: f32=mediumRoot*mediumRoot*mediumRoot;let shortResponse: f32=shortRoot*shortRoot*shortRoot;return vec3f(\n4.0767416621*longResponse-3.3077115913*mediumResponse+0.2309699292*shortResponse,\n-1.2684380046*longResponse+2.6097574011*mediumResponse-0.3413193965*shortResponse,\n-0.0041960863*longResponse-0.7034186147*mediumResponse+1.7076147010*shortResponse\n);}\nfn interpolateMeshBlendColor(currentColor: vec3f,targetColor: vec3f,factor: f32)->vec3f {\n#ifdef MESH_BLEND_COLOR_INTERPOLATION_SRGB\nreturn meshBlendSrgbToLinear(mix(meshBlendLinearToSrgb(currentColor),meshBlendLinearToSrgb(targetColor),factor));\n#else\nreturn meshBlendOklabToLinearSrgb(mix(meshBlendLinearSrgbToOklab(currentColor),meshBlendLinearSrgbToOklab(targetColor),factor));\n#endif\n}\nfn meshBlendLuminance(srgbColor: vec3f)->f32 {return dot(srgbColor,vec3f(0.2126,0.7152,0.0722));}\nfn constructMeshBlendTargetColorSamples(renderSize: vec2i,result: MeshBlendResult)->MeshBlendTargetColorSamples {var samples: MeshBlendTargetColorSamples;let boundaryPlusOnePixel: vec2i=clampPixel(result.targetPixel+vec2i(round(result.candidate.direction)),renderSize);let boundaryPlusTwoPixel: vec2i=clampPixel(result.targetPixel+vec2i(round(result.candidate.direction*2.0)),renderSize);let boundaryPlusOneTag: MeshBlendTag=loadMeshBlendTag(boundaryPlusOnePixel,renderSize);let boundaryPlusTwoTag: MeshBlendTag=loadMeshBlendTag(boundaryPlusTwoPixel,renderSize);samples.fartherColor=textureLoad(textureSampler,result.targetFarPixel,0);samples.boundaryPlusOneColor=textureLoad(textureSampler,boundaryPlusOnePixel,0);samples.boundaryPlusTwoColor=textureLoad(textureSampler,boundaryPlusTwoPixel,0);\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nsamples.fartherBaseColor=textureLoad(meshBlendBaseColorSampler,result.targetFarPixel,0).rgb;let boundaryPlusOneBaseColor: vec3f=textureLoad(meshBlendBaseColorSampler,boundaryPlusOnePixel,0).rgb;let boundaryPlusTwoBaseColor: vec3f=textureLoad(meshBlendBaseColorSampler,boundaryPlusTwoPixel,0).rgb;\n#endif\nsamples.onePixelEdge=boundaryPlusOneTag.groupId != result.candidate.targetGroupId;if (samples.onePixelEdge) {samples.conservativeNearColor=samples.fartherColor;\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nsamples.conservativeNearBaseColor=samples.fartherBaseColor;\n#endif\nsamples.targetColor=samples.fartherColor;return samples;}\nlet secondNearSampleIsTarget: bool=boundaryPlusTwoTag.groupId==result.candidate.targetGroupId;let firstNearLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(samples.boundaryPlusOneColor.rgb));let secondNearLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(samples.boundaryPlusTwoColor.rgb));let useSecondNearSample: bool=secondNearSampleIsTarget && secondNearLuminance<firstNearLuminance;if (useSecondNearSample) {samples.conservativeNearColor=samples.boundaryPlusTwoColor;\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nsamples.conservativeNearBaseColor=boundaryPlusTwoBaseColor;\n#endif\n} else {samples.conservativeNearColor=samples.boundaryPlusOneColor;\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nsamples.conservativeNearBaseColor=boundaryPlusOneBaseColor;\n#endif\n}\nsamples.targetColor=mix(samples.fartherColor,samples.conservativeNearColor,MESH_BLEND_NEAR_EDGE_TARGET_WEIGHT);return samples;}\nfn applyMeshBlendNearSeamCorrection(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\nresult: MeshBlendResult,\nsamples: MeshBlendTargetColorSamples,\ncurrentColor: vec4f,\ncorrected: ptr<function,bool>\n)->vec4f {*corrected=false;if (!samples.onePixelEdge || result.candidate.distancePixels>MESH_BLEND_NEAR_SEAM_MAX_DISTANCE) {return currentColor;}\nlet oppositePixel: vec2i=clampPixel(pixel-vec2i(round(result.candidate.direction)),renderSize);let oppositeTag: MeshBlendTag=loadMeshBlendTag(oppositePixel,renderSize);if (oppositeTag.groupId != currentTag.groupId) {return currentColor;}\nlet oppositeColor: vec4f=textureLoad(textureSampler,oppositePixel,0);let currentTargetDistance: f32=distance(currentColor.rgb,samples.targetColor.rgb);let oppositeTargetDistance: f32=distance(oppositeColor.rgb,samples.targetColor.rgb);if (currentTargetDistance+MESH_BLEND_NEAR_SEAM_COLOR_DELTA>=oppositeTargetDistance) {return currentColor;}\n*corrected=true;return oppositeColor;}\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nfn estimateMeshBlendShadow(renderedLinear: vec3f,baseColorLinear: vec3f)->f32 {let renderedLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(renderedLinear));let baseLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(baseColorLinear));if (baseLuminance<=MESH_BLEND_BASE_LUMINANCE_EPSILON) {return 1.0;}\nreturn renderedLuminance/baseLuminance;}\nfn calculateMeshBlendShadowAttenuation(currentColor: vec3f,samples: MeshBlendTargetColorSamples)->f32 {let fartherShadow: f32=estimateMeshBlendShadow(samples.fartherColor.rgb,samples.fartherBaseColor);let nearShadow: f32=estimateMeshBlendShadow(samples.conservativeNearColor.rgb,samples.conservativeNearBaseColor);let shadowDifference: f32=abs(fartherShadow-nearShadow);let shadowMismatch: f32=smoothstep(MESH_BLEND_SHADOW_DIFFERENCE_LOW,MESH_BLEND_SHADOW_DIFFERENCE_HIGH,shadowDifference);let currentLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(currentColor));let targetLuminance: f32=meshBlendLuminance(meshBlendLinearToSrgb(samples.targetColor.rgb));let targetToCurrentRatio: f32=targetLuminance/max(currentLuminance,MESH_BLEND_BASE_LUMINANCE_EPSILON);let targetIsNotDark: f32=smoothstep(MESH_BLEND_TARGET_DARKER_RATIO,MESH_BLEND_TARGET_NON_DARK_RATIO,targetToCurrentRatio);return mix(1.0,MESH_BLEND_SHADOW_MIN_ATTENUATION,shadowMismatch*targetIsNotDark);}\n#endif\nfn evaluateMeshBlendColor(\npixel: vec2i,\nrenderSize: vec2i,\ncurrentTag: MeshBlendTag,\nresult: MeshBlendResult\n)->MeshBlendColorEvaluation {var evaluation: MeshBlendColorEvaluation;evaluation.samples=constructMeshBlendTargetColorSamples(renderSize,result);\n#ifdef MESH_BLEND_DEBUG_WORLD_POSITION\nevaluation.worldPosition=reconstructMeshBlendWorldPosition(result.currentViewPosition);\n#endif\nlet currentSceneColor: vec4f=textureLoad(textureSampler,pixel,0);var nearSeamCorrected: bool=false;evaluation.currentColor=applyMeshBlendNearSeamCorrection(\npixel,\nrenderSize,\ncurrentTag,\nresult,\nevaluation.samples,\ncurrentSceneColor,\n&nearSeamCorrected\n);evaluation.nearSeamCorrected=nearSeamCorrected;evaluation.shadowAttenuation=1.0;\n#ifdef MESH_BLEND_SHADOW_ESTIMATION\nevaluation.shadowAttenuation=calculateMeshBlendShadowAttenuation(evaluation.currentColor.rgb,evaluation.samples);\n#endif\nevaluation.adjustedFade=result.fade*evaluation.shadowAttenuation;evaluation.blendedColor=vec4f(\ninterpolateMeshBlendColor(evaluation.currentColor.rgb,evaluation.samples.targetColor.rgb,evaluation.adjustedFade),\nmix(evaluation.currentColor.a,evaluation.samples.targetColor.a,evaluation.adjustedFade)\n);return evaluation;}\nfn radiusClassDebugColor(radiusClass: u32)->vec3f {if (radiusClass==0u) {return vec3f(0.15,0.55,1.0);}\nif (radiusClass==1u) {return vec3f(0.15,0.9,0.35);}\nif (radiusClass==2u) {return vec3f(1.0,0.65,0.1);}\nreturn vec3f(0.95,0.2,0.65);}\nfn validationDebugColor(rejectionReason: i32,narrowedRadiusRatio: f32)->vec3f {if (rejectionReason==MESH_BLEND_REJECTION_NONE) {return mix(vec3f(0.1,0.55,1.0),vec3f(0.2,1.0,0.25),narrowedRadiusRatio);}\nif (rejectionReason==MESH_BLEND_REJECTION_NO_CANDIDATE) {return vec3f(0.12);}\nif (rejectionReason==MESH_BLEND_REJECTION_NO_CONTINUATION) {return vec3f(0.75,0.1,0.85);}\nif (rejectionReason==MESH_BLEND_REJECTION_INVALID_DEPTH) {return vec3f(1.0,0.0,1.0);}\nif (rejectionReason==MESH_BLEND_REJECTION_DEPTH_SEPARATION) {return vec3f(1.0,0.1,0.1);}\nif (rejectionReason==MESH_BLEND_REJECTION_FOREGROUND_BACKGROUND) {return vec3f(1.0,0.4,0.05);}\nif (rejectionReason==MESH_BLEND_REJECTION_PHYSICAL_SPAN) {return vec3f(1.0,0.9,0.05);}\nreturn vec3f(0.05,0.8,1.0);}\nfn processingStageDebugColor(stageReached: i32)->vec3f {if (stageReached<=0) {return vec3f(0.03);}\nif (stageReached==1) {return vec3f(0.1,0.15,0.45);}\nif (stageReached==2) {return vec3f(0.1,0.35,0.7);}\nif (stageReached==3) {return vec3f(0.05,0.65,0.8);}\nif (stageReached==4) {return vec3f(0.1,0.8,0.55);}\nif (stageReached==5) {return vec3f(0.45,0.9,0.25);}\nif (stageReached==6) {return vec3f(0.95,0.75,0.1);}\nreturn vec3f(0.15,1.0,0.25);}\nfn candidateDebugColor(result: MeshBlendResult)->vec3f {if (!result.candidate.valid) {return vec3f(0.04);}\nlet normalizedDistance: f32=clamp(\nresult.candidate.distancePixels/max(result.candidate.searchRadiusPixels,MESH_BLEND_EPSILON),\n0.0,\n1.0\n);return vec3f(result.candidate.direction*0.5+0.5,1.0-normalizedDistance);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {let renderSize: vec2i=vec2i(textureDimensions(meshBlendDepthSampler,0));let pixel: vec2i=clampPixel(vec2i(floor(input.vUV*vec2f(renderSize))),renderSize);let currentTag: MeshBlendTag=loadMeshBlendTag(pixel,renderSize);\n#ifdef MESH_BLEND_DEBUG_PACKED_TAG\nlet groupVariation: f32=0.45+0.55*fract(f32(currentTag.groupId)*0.61803398875);let tagColor: vec3f=radiusClassDebugColor(currentTag.radiusClass)*groupVariation;if (currentTag.groupId==0u) {fragmentOutputs.color=vec4f(0.0,0.0,0.0,1.0);} else {fragmentOutputs.color=vec4f(tagColor,1.0);}\nreturn fragmentOutputs;\n#endif\nif (currentTag.groupId==0u) {\n#ifdef MESH_BLEND_DEBUG_SEAM_FADE\nfragmentOutputs.color=vec4f(0.0,0.0,0.0,1.0);\n#elif defined(MESH_BLEND_DEBUG_ENABLED)\nfragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);\n#else\nfragmentOutputs.color=textureLoad(textureSampler,pixel,0);\n#endif\nreturn fragmentOutputs;}\nlet sizingDepth: f32=loadMeshBlendDepth(pixel,renderSize);let sizingPosition: vec3f=reconstructMeshBlendViewPosition(pixel,renderSize,sizingDepth);if (!isValidMeshBlendPosition(sizingPosition)) {\n#ifdef MESH_BLEND_DEBUG_REJECTION_REASON\nfragmentOutputs.color=vec4f(validationDebugColor(MESH_BLEND_REJECTION_INVALID_DEPTH,0.0),1.0);\n#elif defined(MESH_BLEND_DEBUG_STAGE_WORK)\nfragmentOutputs.color=vec4f(0.45,0.1,0.1,1.0);\n#elif defined(MESH_BLEND_DEBUG_ENABLED)\nfragmentOutputs.color=vec4f(0.4,0.05,0.4,1.0);\n#else\nfragmentOutputs.color=textureLoad(textureSampler,pixel,0);\n#endif\nreturn fragmentOutputs;}\nlet currentViewDepth: f32=abs(sizingPosition.z);let currentSearchRadius: f32=searchRadiusForClass(currentTag.radiusClass,currentViewDepth,f32(renderSize.y));if (currentSearchRadius<1.0) {\n#ifdef MESH_BLEND_DEBUG_SEAM_FADE\nfragmentOutputs.color=vec4f(radiusClassDebugColor(currentTag.radiusClass)*0.25,1.0);\n#elif defined(MESH_BLEND_DEBUG_REJECTION_REASON)\nfragmentOutputs.color=vec4f(validationDebugColor(MESH_BLEND_REJECTION_PHYSICAL_SPAN,0.0),1.0);\n#elif defined(MESH_BLEND_DEBUG_STAGE_WORK)\nfragmentOutputs.color=vec4f(0.2,0.2,0.65,1.0);\n#elif defined(MESH_BLEND_DEBUG_ENABLED)\nfragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);\n#else\nfragmentOutputs.color=textureLoad(textureSampler,pixel,0);\n#endif\nreturn fragmentOutputs;}\nlet randomValues: vec2f=loadStableBlueNoise(pixel);let sectorAngle: f32=MESH_BLEND_TWO_PI/f32(MESH_BLEND_DIRECTION_COUNT);var rotation: f32;\n#ifdef MESH_BLEND_FULL_RANDOM_ROTATION\nrotation=randomValues.x*sectorAngle;\n#else\nrotation=floor(randomValues.x*8.0)*0.125*sectorAngle;\n#endif\nlet direction0: vec2f=vec2f(cos(rotation),sin(rotation));let direction1: vec2f=vec2f(cos(rotation+sectorAngle),sin(rotation+sectorAngle));let direction2: vec2f=vec2f(cos(rotation+sectorAngle*2.0),sin(rotation+sectorAngle*2.0));let primaryResult: MeshBlendResult=evaluateMeshBlend(\npixel,\nrenderSize,\ncurrentTag,\ncurrentSearchRadius,\ncurrentViewDepth,\n0u,\nrandomValues,\nrotation,\nsectorAngle,\ndirection0,\ndirection1,\ndirection2\n);var secondaryResult: MeshBlendResult=invalidBlendResult();\n#ifdef MESH_BLEND_MULTI_TARGET_SECONDARY_BLEND\nif (primaryResult.valid) {secondaryResult=evaluateMeshBlend(\npixel,\nrenderSize,\ncurrentTag,\ncurrentSearchRadius,\ncurrentViewDepth,\nprimaryResult.candidate.targetGroupId,\nrandomValues,\nrotation,\nsectorAngle,\ndirection0,\ndirection1,\ndirection2\n);}\n#endif\n#ifdef MESH_BLEND_DEBUG_CANDIDATE_DIRECTION_DISTANCE\nfragmentOutputs.color=vec4f(candidateDebugColor(primaryResult),1.0);return fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_CONTINUATION)\nif (!primaryResult.candidate.valid) {fragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);} else if (primaryResult.rejectionReason==MESH_BLEND_REJECTION_NO_CONTINUATION) {fragmentOutputs.color=vec4f(0.85,0.05,0.7,1.0);} else if (primaryResult.usedFallback) {fragmentOutputs.color=vec4f(1.0,0.75,0.05,1.0);} else {fragmentOutputs.color=vec4f(0.1,0.9,0.25,1.0);}\nreturn fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_TINY_OBJECT)\n#ifdef MESH_BLEND_TINY_OBJECT_SAFEGUARD\nif (!primaryResult.candidate.valid) {fragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);} else {let radiusColor: vec3f=mix(vec3f(1.0,0.1,0.05),vec3f(0.1,0.65,1.0),primaryResult.tinyObjectRadiusRatio);if (primaryResult.tinyObjectRadiusReduced) {fragmentOutputs.color=vec4f(radiusColor,1.0);} else {fragmentOutputs.color=vec4f(radiusColor*0.45,1.0);}}\n#else\nfragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);\n#endif\nreturn fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_MULTI_TARGET)\n#ifdef MESH_BLEND_MULTI_TARGET_SECONDARY_BLEND\nif (secondaryResult.valid) {fragmentOutputs.color=vec4f(0.95,0.95,1.0,1.0);} else if (secondaryResult.candidate.valid) {fragmentOutputs.color=vec4f(0.8,0.15,0.75,1.0);} else if (primaryResult.valid) {fragmentOutputs.color=vec4f(0.1,0.45,0.95,1.0);} else {fragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);}\n#else\nif (primaryResult.valid) {fragmentOutputs.color=vec4f(0.1,0.45,0.95,1.0);} else {fragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);}\n#endif\nreturn fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_REJECTION_REASON)\nvar narrowedRadiusRatio: f32=0.0;if (primaryResult.candidate.valid) {narrowedRadiusRatio=primaryResult.effectiveRadiusPixels/max(primaryResult.candidate.searchRadiusPixels,MESH_BLEND_EPSILON);}\nfragmentOutputs.color=vec4f(validationDebugColor(primaryResult.rejectionReason,narrowedRadiusRatio),1.0);return fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_STAGE_WORK)\nvar stageReached: i32=primaryResult.stageReached;\n#ifdef MESH_BLEND_MULTI_TARGET_SECONDARY_BLEND\nstageReached=max(stageReached,secondaryResult.stageReached);\n#endif\nfragmentOutputs.color=vec4f(processingStageDebugColor(stageReached),1.0);return fragmentOutputs;\n#endif\nif (!primaryResult.valid) {\n#ifdef MESH_BLEND_DEBUG_SEAM_FADE\nvar debugRadiusClass: u32=currentTag.radiusClass;if (primaryResult.candidate.valid) {debugRadiusClass=primaryResult.candidate.radiusClass;}\nfragmentOutputs.color=vec4f(radiusClassDebugColor(debugRadiusClass)*0.25,1.0);\n#elif defined(MESH_BLEND_DEBUG_TARGET_COLOR) || defined(MESH_BLEND_DEBUG_SHADOW_ATTENUATION) || defined(MESH_BLEND_DEBUG_COLOR_INTERPOLATION) || defined(MESH_BLEND_DEBUG_WORLD_POSITION)\nfragmentOutputs.color=vec4f(0.04,0.04,0.04,1.0);\n#else\nfragmentOutputs.color=textureLoad(textureSampler,pixel,0);\n#endif\nreturn fragmentOutputs;}\n#ifdef MESH_BLEND_DEBUG_SEAM_FADE\nvar debugFade: f32=primaryResult.fade;\n#ifdef MESH_BLEND_MULTI_TARGET_SECONDARY_BLEND\nif (secondaryResult.valid) {debugFade=min(0.5,primaryResult.fade+secondaryResult.fade);}\n#endif\nlet classColor: vec3f=radiusClassDebugColor(primaryResult.candidate.radiusClass)*0.25;fragmentOutputs.color=vec4f(mix(classColor,vec3f(1.0),clamp(debugFade*2.0,0.0,1.0)),1.0);return fragmentOutputs;\n#else\nlet primaryColorEvaluation: MeshBlendColorEvaluation=evaluateMeshBlendColor(pixel,renderSize,currentTag,primaryResult);\n#ifdef MESH_BLEND_DEBUG_WORLD_POSITION\nfragmentOutputs.color=vec4f(fract(primaryColorEvaluation.worldPosition*0.1),1.0);return fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_TARGET_COLOR)\nlet targetSampleIndex: i32=(pixel.x/4) % 4;if (targetSampleIndex==0) {fragmentOutputs.color=primaryColorEvaluation.samples.fartherColor;} else if (targetSampleIndex==1) {fragmentOutputs.color=primaryColorEvaluation.samples.boundaryPlusOneColor;} else if (targetSampleIndex==2) {fragmentOutputs.color=primaryColorEvaluation.samples.boundaryPlusTwoColor;} else {fragmentOutputs.color=primaryColorEvaluation.samples.targetColor;}\nreturn fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_SHADOW_ATTENUATION)\nvar nearSeamCorrectionDebug: f32=0.0;if (primaryColorEvaluation.nearSeamCorrected) {nearSeamCorrectionDebug=1.0;}\nfragmentOutputs.color=vec4f(\n1.0-primaryColorEvaluation.shadowAttenuation,\nprimaryColorEvaluation.shadowAttenuation,\nnearSeamCorrectionDebug,\n1.0\n);return fragmentOutputs;\n#elif defined(MESH_BLEND_DEBUG_COLOR_INTERPOLATION)\n#ifdef MESH_BLEND_COLOR_INTERPOLATION_SRGB\nlet interpolationModeColor: vec3f=vec3f(1.0,0.4,0.05);\n#else\nlet interpolationModeColor: vec3f=vec3f(0.1,0.75,1.0);\n#endif\nlet interpolationStage: f32=mix(0.35,1.0,clamp(primaryColorEvaluation.adjustedFade*2.0,0.0,1.0));fragmentOutputs.color=vec4f(interpolationModeColor*interpolationStage,1.0);return fragmentOutputs;\n#else\n#ifdef MESH_BLEND_MULTI_TARGET_SECONDARY_BLEND\nif (secondaryResult.valid) {let secondaryColorEvaluation: MeshBlendColorEvaluation=evaluateMeshBlendColor(pixel,renderSize,currentTag,secondaryResult);let totalBoundaryDistance: f32=max(\nprimaryResult.candidate.distancePixels+secondaryResult.candidate.distancePixels,\nMESH_BLEND_EPSILON\n);let primaryRelativeProximity: f32=secondaryResult.candidate.distancePixels/totalBoundaryDistance;let secondaryRelativeProximity: f32=primaryResult.candidate.distancePixels/totalBoundaryDistance;let primaryWeight: f32=primaryColorEvaluation.adjustedFade*primaryRelativeProximity;let secondaryWeight: f32=secondaryColorEvaluation.adjustedFade*secondaryRelativeProximity;let combinedWeight: f32=primaryWeight+secondaryWeight;if (combinedWeight<=MESH_BLEND_EPSILON) {fragmentOutputs.color=textureLoad(textureSampler,pixel,0);return fragmentOutputs;}\nfragmentOutputs.color =\n(primaryColorEvaluation.blendedColor*primaryWeight+secondaryColorEvaluation.blendedColor*secondaryWeight)/combinedWeight;return fragmentOutputs;}\n#endif\nfragmentOutputs.color=primaryColorEvaluation.blendedColor;\n#endif\n#endif\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\n\n/** @internal */\nexport const meshBlendingPixelShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/openpbr.fragment.js CHANGED Viewed

@@ -62,6 +62,7 @@ import { openpbrDirectLightingWGSL } from "./ShadersInclude/openpbrDirectLightin
 import { logDepthFragmentWGSL } from "./ShadersInclude/logDepthFragment.js";
 import { fogFragmentWGSL } from "./ShadersInclude/fogFragment.js";
 import { pbrBlockImageProcessingWGSL } from "./ShadersInclude/pbrBlockImageProcessing.js";
+import { meshBlendTagFragmentOutputWGSL } from "./ShadersInclude/meshBlendTagFragmentOutput.js";
 import { openpbrBlockPrePassWGSL } from "./ShadersInclude/openpbrBlockPrePass.js";
 import { oitFragmentWGSL } from "./ShadersInclude/oitFragment.js";
 import { pbrDebugWGSL } from "./ShadersInclude/pbrDebug.js";
@@ -299,7 +300,7 @@ if (fragDepth==nearestDepth) {fragmentOutputs.frontColor=vec4f(fragmentOutputs.f
 if (!ShaderStore.ShadersStoreWGSL[name]) {
     ShaderStore.ShadersStoreWGSL[name] = shader;
 }
-const includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, openpbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, openpbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, openpbrNormalMapFragmentMainFunctionsWGSL, openpbrNormalMapFragmentFunctionsWGSL, reflectionFunctionWGSL, openpbrDielectricReflectanceWGSL, openpbrConductorReflectanceWGSL, openpbrAmbientOcclusionFunctionsWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, openpbrVolumeFunctionsWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, openpbrNormalMapFragmentWGSL, openpbrBlockNormalFinalWGSL, openpbrBaseLayerDataWGSL, openpbrTransmissionLayerDataWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrCoatLayerDataWGSL, openpbrThinFilmLayerDataWGSL, openpbrFuzzLayerDataWGSL, openpbrAmbientOcclusionDataWGSL, depthPrePassWGSL, openpbrBackgroundTransmissionWGSL, openpbrEnvironmentLightingWGSL, openpbrDirectLightingInitWGSL, openpbrDirectLightingWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, openpbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];
+const includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, openpbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, openpbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, openpbrNormalMapFragmentMainFunctionsWGSL, openpbrNormalMapFragmentFunctionsWGSL, reflectionFunctionWGSL, openpbrDielectricReflectanceWGSL, openpbrConductorReflectanceWGSL, openpbrAmbientOcclusionFunctionsWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, openpbrVolumeFunctionsWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, openpbrNormalMapFragmentWGSL, openpbrBlockNormalFinalWGSL, openpbrBaseLayerDataWGSL, openpbrTransmissionLayerDataWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrCoatLayerDataWGSL, openpbrThinFilmLayerDataWGSL, openpbrFuzzLayerDataWGSL, openpbrAmbientOcclusionDataWGSL, depthPrePassWGSL, openpbrBackgroundTransmissionWGSL, openpbrEnvironmentLightingWGSL, openpbrDirectLightingInitWGSL, openpbrDirectLightingWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, meshBlendTagFragmentOutputWGSL, openpbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];
 for (const inc of includes) {
     if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
         ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;

package/ShadersWGSL/openpbr.fragment.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"openpbr.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/openpbr.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAC/F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,oCAAoC,EAAE,MAAM,mDAAmD,CAAC;AACzG,OAAO,EAAE,sCAAsC,EAAE,MAAM,qDAAqD,CAAC;AAC7G,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACnG,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,mCAAmC,EAAE,MAAM,kDAAkD,CAAC;AACvG,OAAO,EAAE,qCAAqC,EAAE,MAAM,oDAAoD,CAAC;AAC3G,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACnG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,yCAAyC,EAAE,MAAM,wDAAwD,CAAC;AACnH,OAAO,EAAE,qCAAqC,EAAE,MAAM,oDAAoD,CAAC;AAC3G,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAC/F,OAAO,EAAE,oCAAoC,EAAE,MAAM,mDAAmD,CAAC;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,+BAA+B,EAAE,MAAM,8CAA8C,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACnG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoOd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,+BAA+B,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,oCAAoC,EAAE,sCAAsC,EAAE,8BAA8B,EAAE,gCAAgC,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,mBAAmB,EAAE,iCAAiC,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,4BAA4B,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,mCAAmC,EAAE,qCAAqC,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,8BAA8B,EAAE,wBAAwB,EAAE,iCAAiC,EAAE,8BAA8B,EAAE,mBAAmB,EAAE,yCAAyC,EAAE,qCAAqC,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,+BAA+B,EAAE,oCAAoC,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,gCAAgC,EAAE,8BAA8B,EAAE,wBAAwB,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,iCAAiC,EAAE,8BAA8B,EAAE,6BAA6B,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,eAAe,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;AAC30D,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { objectIdFunctionsWGSL } from \"./ShadersInclude/objectIdFunctions\";\nimport { prePassDeclarationWGSL } from \"./ShadersInclude/prePassDeclaration\";\nimport { oitDeclarationWGSL } from \"./ShadersInclude/oitDeclaration\";\nimport { sceneUboDeclarationWGSL } from \"./ShadersInclude/sceneUboDeclaration\";\nimport { meshUboDeclarationWGSL } from \"./ShadersInclude/meshUboDeclaration\";\nimport { openpbrUboDeclarationWGSL } from \"./ShadersInclude/openpbrUboDeclaration\";\nimport { mainUVVaryingDeclarationWGSL } from \"./ShadersInclude/mainUVVaryingDeclaration\";\nimport { pbrFragmentExtraDeclarationWGSL } from \"./ShadersInclude/pbrFragmentExtraDeclaration\";\nimport { lightUboDeclarationWGSL } from \"./ShadersInclude/lightUboDeclaration\";\nimport { samplerFragmentDeclarationWGSL } from \"./ShadersInclude/samplerFragmentDeclaration\";\nimport { pbrFragmentReflectionDeclarationWGSL } from \"./ShadersInclude/pbrFragmentReflectionDeclaration\";\nimport { openpbrFragmentSamplersDeclarationWGSL } from \"./ShadersInclude/openpbrFragmentSamplersDeclaration\";\nimport { imageProcessingDeclarationWGSL } from \"./ShadersInclude/imageProcessingDeclaration\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { fogFragmentDeclarationWGSL } from \"./ShadersInclude/fogFragmentDeclaration\";\nimport { textureRepetitionFunctionsWGSL } from \"./ShadersInclude/textureRepetitionFunctions\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { subSurfaceScatteringFunctionsWGSL } from \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport { importanceSamplingWGSL } from \"./ShadersInclude/importanceSampling\";\nimport { pbrHelperFunctionsWGSL } from \"./ShadersInclude/pbrHelperFunctions\";\nimport { imageProcessingFunctionsWGSL } from \"./ShadersInclude/imageProcessingFunctions\";\nimport { shadowsFragmentFunctionsWGSL } from \"./ShadersInclude/shadowsFragmentFunctions\";\nimport { harmonicsFunctionsWGSL } from \"./ShadersInclude/harmonicsFunctions\";\nimport { ltcHelperFunctionsWGSL } from \"./ShadersInclude/ltcHelperFunctions\";\nimport { pbrDirectLightingSetupFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingSetupFunctions\";\nimport { pbrDirectLightingFalloffFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingFalloffFunctions\";\nimport { pbrBRDFFunctionsWGSL } from \"./ShadersInclude/pbrBRDFFunctions\";\nimport { hdrFilteringFunctionsWGSL } from \"./ShadersInclude/hdrFilteringFunctions\";\nimport { clusteredLightingFunctionsWGSL } from \"./ShadersInclude/clusteredLightingFunctions\";\nimport { pbrBlockReflectance0WGSL } from \"./ShadersInclude/pbrBlockReflectance0\";\nimport { pbrClusteredLightingFunctionsWGSL } from \"./ShadersInclude/pbrClusteredLightingFunctions\";\nimport { pbrDirectLightingFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingFunctions\";\nimport { pbrIBLFunctionsWGSL } from \"./ShadersInclude/pbrIBLFunctions\";\nimport { openpbrNormalMapFragmentMainFunctionsWGSL } from \"./ShadersInclude/openpbrNormalMapFragmentMainFunctions\";\nimport { openpbrNormalMapFragmentFunctionsWGSL } from \"./ShadersInclude/openpbrNormalMapFragmentFunctions\";\nimport { reflectionFunctionWGSL } from \"./ShadersInclude/reflectionFunction\";\nimport { openpbrDielectricReflectanceWGSL } from \"./ShadersInclude/openpbrDielectricReflectance\";\nimport { openpbrConductorReflectanceWGSL } from \"./ShadersInclude/openpbrConductorReflectance\";\nimport { openpbrAmbientOcclusionFunctionsWGSL } from \"./ShadersInclude/openpbrAmbientOcclusionFunctions\";\nimport { openpbrGeometryInfoWGSL } from \"./ShadersInclude/openpbrGeometryInfo\";\nimport { openpbrIblFunctionsWGSL } from \"./ShadersInclude/openpbrIblFunctions\";\nimport { openpbrVolumeFunctionsWGSL } from \"./ShadersInclude/openpbrVolumeFunctions\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { pbrBlockNormalGeometricWGSL } from \"./ShadersInclude/pbrBlockNormalGeometric\";\nimport { openpbrNormalMapFragmentWGSL } from \"./ShadersInclude/openpbrNormalMapFragment\";\nimport { openpbrBlockNormalFinalWGSL } from \"./ShadersInclude/openpbrBlockNormalFinal\";\nimport { openpbrBaseLayerDataWGSL } from \"./ShadersInclude/openpbrBaseLayerData\";\nimport { openpbrTransmissionLayerDataWGSL } from \"./ShadersInclude/openpbrTransmissionLayerData\";\nimport { openpbrSubsurfaceLayerDataWGSL } from \"./ShadersInclude/openpbrSubsurfaceLayerData\";\nimport { openpbrCoatLayerDataWGSL } from \"./ShadersInclude/openpbrCoatLayerData\";\nimport { openpbrThinFilmLayerDataWGSL } from \"./ShadersInclude/openpbrThinFilmLayerData\";\nimport { openpbrFuzzLayerDataWGSL } from \"./ShadersInclude/openpbrFuzzLayerData\";\nimport { openpbrAmbientOcclusionDataWGSL } from \"./ShadersInclude/openpbrAmbientOcclusionData\";\nimport { depthPrePassWGSL } from \"./ShadersInclude/depthPrePass\";\nimport { openpbrBackgroundTransmissionWGSL } from \"./ShadersInclude/openpbrBackgroundTransmission\";\nimport { openpbrEnvironmentLightingWGSL } from \"./ShadersInclude/openpbrEnvironmentLighting\";\nimport { openpbrDirectLightingInitWGSL } from \"./ShadersInclude/openpbrDirectLightingInit\";\nimport { openpbrDirectLightingWGSL } from \"./ShadersInclude/openpbrDirectLighting\";\nimport { logDepthFragmentWGSL } from \"./ShadersInclude/logDepthFragment\";\nimport { fogFragmentWGSL } from \"./ShadersInclude/fogFragment\";\nimport { pbrBlockImageProcessingWGSL } from \"./ShadersInclude/pbrBlockImageProcessing\";\nimport { openpbrBlockPrePassWGSL } from \"./ShadersInclude/openpbrBlockPrePass\";\nimport { oitFragmentWGSL } from \"./ShadersInclude/oitFragment\";\nimport { pbrDebugWGSL } from \"./ShadersInclude/pbrDebug\";\n\nconst name = \"openpbrPixelShader\";\nconst shader = `#define OPENPBR_FRAGMENT_SHADER\n#define CUSTOM_FRAGMENT_BEGIN\n#include<prePassDeclaration>[SCENE_MRT_COUNT]\n#include<oitDeclaration>\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE\n#endif\n#include<openpbrUboDeclaration>\n#include<pbrFragmentExtraDeclaration>\n#include<lightUboDeclaration>[0..maxSimultaneousLights]\n#include<openpbrFragmentSamplersDeclaration>\n#include<imageProcessingDeclaration>\n#include<clipPlaneFragmentDeclaration>\n#include<logDepthDeclaration>\n#include<fogFragmentDeclaration>\n#include<textureRepetitionFunctions>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<importanceSampling>\n#include<pbrHelperFunctions>\n#include<imageProcessingFunctions>\n#include<shadowsFragmentFunctions>\n#include<harmonicsFunctions>\n#include<pbrDirectLightingSetupFunctions>\n#include<pbrDirectLightingFalloffFunctions>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\n#include<pbrDirectLightingFunctions>\n#include<pbrIBLFunctions>\n#include<openpbrNormalMapFragmentMainFunctions>\n#include<openpbrNormalMapFragmentFunctions>\n#ifdef REFLECTION\n#include<reflectionFunction>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\n#include<openpbrDielectricReflectance>\n#include<openpbrConductorReflectance>\n#include<openpbrAmbientOcclusionFunctions>\n#include<openpbrGeometryInfo>\n#include<openpbrIblFunctions>\n#include<openpbrVolumeFunctions>\nfn layer(slab_bottom: vec3f,slab_top: vec3f,lerp_factor: f32,bottom_multiplier: vec3f,top_multiplier: vec3f)->vec3f {return mix(slab_bottombottom_multiplier,slab_toptop_multiplier,lerp_factor);}\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#ifdef PREPASS_IRRADIANCE\nvar total_direct_diffuse: vec3f=vec3f(0.0f);\n#endif\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\n#include<pbrBlockNormalGeometric>\nvar coatNormalW: vec3f=normalW;\n#include<openpbrNormalMapFragment>\n#include<openpbrBlockNormalFinal>\n#include<openpbrBaseLayerData>\n#include<openpbrTransmissionLayerData>\n#include<openpbrSubsurfaceLayerData>\n#include<openpbrCoatLayerData>\n#include<openpbrThinFilmLayerData>\n#include<openpbrFuzzLayerData>\n#include<openpbrAmbientOcclusionData>\n#define CUSTOM_FRAGMENT_UPDATE_ALPHA\n#define DEPTHPREPASS_SKIP_EARLY_RETURN\n#include<depthPrePass>\n#ifndef DEPTHPREPASS\n#define CUSTOM_FRAGMENT_BEFORE_LIGHTS\n#ifdef ANISOTROPIC_COAT\nlet coatGeoInfo: geometryInfoAnisoOutParams=geometryInfoAniso(\ncoatNormalW,viewDirectionW.xyz,coat_roughness,geometricNormalW\n,vec3f(geometry_coat_tangent.x,geometry_coat_tangent.y,coat_roughness_anisotropy),TBN\n);\n#else\nlet coatGeoInfo: geometryInfoOutParams=geometryInfo(\ncoatNormalW,viewDirectionW.xyz,coat_roughness,geometricNormalW\n);\n#endif\nspecular_roughness=mix(specular_roughness,pow(min(1.0f,pow(specular_roughness,4.0f)+2.0fpow(coat_roughness,4.0f)),0.25f),coat_weight);\n#ifdef ANISOTROPIC_BASE\nlet baseGeoInfo: geometryInfoAnisoOutParams=geometryInfoAniso(\nnormalW,viewDirectionW.xyz,specular_roughness,geometricNormalW\n,vec3f(geometry_tangent.x,geometry_tangent.y,specular_roughness_anisotropy),TBN\n);\n#else\nlet baseGeoInfo: geometryInfoOutParams=geometryInfo(\nnormalW,viewDirectionW.xyz,specular_roughness,geometricNormalW\n);\n#endif\n#ifdef FUZZ\nlet fuzzNormalW=normalize(mix(normalW,coatNormalW,coat_weight));var fuzzTangent=normalize(TBN[0]);fuzzTangent=normalize(fuzzTangent-dot(fuzzTangent,fuzzNormalW)fuzzNormalW);let fuzzBitangent=cross(fuzzNormalW,fuzzTangent);let fuzzGeoInfo: geometryInfoOutParams=geometryInfo(\nfuzzNormalW,viewDirectionW.xyz,fuzz_roughness,geometricNormalW\n);\n#endif\nlet coatReflectance: ReflectanceParams=dielectricReflectance(\ncoat_ior \n,1.0f \n,vec3f(1.0f)\n,coat_weight\n);\n#ifdef THIN_FILM\nlet thin_film_outside_ior: f32=mix(1.0f,coat_ior,coat_weight);\n#endif\nlet baseDielectricReflectance: ReflectanceParams=dielectricReflectance(\nspecular_ior \n,mix(1.0f,coat_ior,coat_weight) \n,specular_color\n,specular_weight\n);let baseConductorReflectance: ReflectanceParams=conductorReflectance(base_color,specular_color,specular_weight);var volume_absorption: vec3f=vec3f(1.0f);var transmission_tint: vec3f=vec3f(1.0f);var surface_translucency_weight: f32=0.0f;\n#if defined(REFRACTED_BACKGROUND) \|\| defined(REFRACTED_ENVIRONMENT) \|\| defined(REFRACTED_LIGHTS)\n#if defined(GEOMETRY_THIN_WALLED)\nlet refractedViewVector: vec3f=-viewDirectionW;\n#else\n#ifdef DISPERSION\nvar refractedViewVectors: array<vec3f,3>;let iorDispersionSpread: f32=transmission_dispersion_scale/transmission_dispersion_abbe_number(specular_ior-1.0f);let dispersion_iors: vec3f=vec3f(specular_ior-iorDispersionSpread,specular_ior,specular_ior+iorDispersionSpread);for (var i: i32=0; i<3; i++) {refractedViewVectors[i]=double_refract(-viewDirectionW,normalW,dispersion_iors[i]); }\n#else\nlet refractedViewVector: vec3f=double_refract(-viewDirectionW,normalW,specular_ior);\n#endif\n#endif\n#ifdef GEOMETRY_THIN_WALLED\nvar transmission_roughness: f32=specular_roughness;\n#else\nvar transmission_roughness: f32=specular_roughnessclamp(4.0f(specular_ior-1.0f),0.001f,1.0f);\n#endif\n#if (defined(TRANSMISSION_SLAB) \|\| defined(SUBSURFACE_SLAB))\nvar volumeParams: OpenPBRHomogeneousVolume;{\n#if defined(TRANSMISSION_SLAB)\nlet transmissionVolumeParams: OpenPBRHomogeneousVolume=computeOpenPBRTransmissionVolume(\ntransmission_color.rgb,\ntransmission_depth,\ntransmission_scatter.rgb,\ntransmission_scatter_anisotropy\n);\n#endif\n#if defined(SUBSURFACE_SLAB)\nlet subsurfaceVolumeParams: OpenPBRHomogeneousVolume=computeOpenPBRSubsurfaceVolume(\nsubsurface_color.rgb,\nsubsurface_radius,\nsubsurface_radius_scale.rgb,\nsubsurface_scatter_anisotropy\n);\n#endif\n#if !defined(TRANSMISSION_SLAB)\nvolumeParams=subsurfaceVolumeParams;surface_translucency_weight=subsurface_weight;\n#elif !defined(SUBSURFACE_SLAB)\nvolumeParams=transmissionVolumeParams;\n#ifdef TRANSMISSION_SLAB_VOLUME\nvolumeParams.multi_scatter_color=singleScatterToMultiScatterAlbedo(volumeParams.ss_albedo);\n#endif\nsurface_translucency_weight=transmission_weight;\n#else\nlet subsurface_fraction_of_dielectric: f32=(1.0f-transmission_weight)subsurface_weight;let subsurface_and_transmission_fraction_of_dielectric: f32=subsurface_fraction_of_dielectric+transmission_weight;let reciprocal_of_subsurface_and_transmission_fraction_of_dielectric: f32 =\n1.0f/maxEps(subsurface_and_transmission_fraction_of_dielectric);let trans_weight: f32=transmission_weightreciprocal_of_subsurface_and_transmission_fraction_of_dielectric;let subsurf_weight: f32=subsurface_fraction_of_dielectricreciprocal_of_subsurface_and_transmission_fraction_of_dielectric;volumeParams.scatter_coeff=transmissionVolumeParams.scatter_coefftrans_weight+subsurfaceVolumeParams.scatter_coeffsubsurf_weight;volumeParams.absorption_coeff=transmissionVolumeParams.absorption_coefftrans_weight+subsurfaceVolumeParams.absorption_coeffsubsurf_weight;volumeParams.anisotropy=(transmissionVolumeParams.anisotropytrans_weight+subsurfaceVolumeParams.anisotropysubsurf_weight)/maxEps(trans_weight+subsurf_weight);volumeParams.extinction_coeff=volumeParams.absorption_coeff+volumeParams.scatter_coeff;volumeParams.ss_albedo=volumeParams.scatter_coeff/maxEpsVec3(volumeParams.extinction_coeff);volumeParams.multi_scatter_color=singleScatterToMultiScatterAlbedo(volumeParams.ss_albedo);surface_translucency_weight=subsurface_and_transmission_fraction_of_dielectric;\n#endif\n}\nvolume_absorption=exp(-volumeParams.absorption_coeffgeometry_thickness);var backscatter_color: vec3f=vec3f(1.0f);{let reduced_scatter: vec3f=volumeParams.scatter_coeffvec3f(1.0f-volumeParams.anisotropy);let reduced_albedo: vec3f=reduced_scatter/(volumeParams.absorption_coeff+reduced_scatter);let sqrt_term: vec3f=max(sqrt(vec3f(1.0f)-reduced_albedo),vec3f(0.0001f));backscatter_color=(vec3f(1.0f)-sqrt_term)/(vec3f(1.0f)+sqrt_term);}\n#elif defined(TRANSMISSION_SLAB)\nsurface_translucency_weight=transmission_weight;\n#endif\n#ifdef SCATTERING\n#ifdef GEOMETRY_THIN_WALLED\nvar iso_scatter_density: vec3f=vec3f(1.0f);\n#else\n#ifdef USE_IRRADIANCE_TEXTURE_FOR_SCATTERING\nlet mfp: vec3f=vec3f(100.0f)/volumeParams.extinction_coeff;var scattered_light_from_irradiance_texture: vec3f=sss_convolve(sceneIrradianceSampler,sceneDepthSampler,uniforms.renderTargetSize,mfp,scene.projection,scene.inverseProjection,SSS_SAMPLE_COUNT,noise.xy);var numLights=f32(LIGHTCOUNT);\n#ifdef REFLECTION\nnumLights+=1.0f;\n#endif\nscattered_light_from_irradiance_texture/=vec3f(numLights);\n#else\nlet scattered_light_from_irradiance_texture: vec3f=vec3f(0.0f);\n#endif\nlet back_to_iso_scattering_blend: f32=min(1.0f+volumeParams.anisotropy,1.0f);let iso_to_forward_scattering_blend: f32=max(volumeParams.anisotropy,0.0f);let iso_scatter_transmittance: vec3f=pow(exp(-volumeParams.scatter_coeffgeometry_thickness),vec3f(0.2f));var iso_scatter_density: vec3f=clamp(vec3f(1.0f)-iso_scatter_transmittance,vec3f(0.0f),vec3f(1.0f));transmission_roughness=min(transmission_roughness+pow((1.0f-abs(volumeParams.anisotropy))max3(iso_scatter_densityiso_scatter_density),3.0f),1.0f);\n#endif\nvolumeParams.multi_scatter_color=mix(volumeParams.ss_albedo,volumeParams.multi_scatter_color,max3(iso_scatter_density));\n#endif\n#if defined(TRANSMISSION_SLAB) && (!defined(TRANSMISSION_SLAB_VOLUME) \|\| defined(GEOMETRY_THIN_WALLED))\ntransmission_tint=transmission_color.rgb;\n#ifdef GEOMETRY_THIN_WALLED\nvar sin2: f32=1.0f-baseGeoInfo.NdotVbaseGeoInfo.NdotV;sin2=sin2/(specular_iorspecular_ior);let cos_t: f32=sqrt(1.0f-sin2);let pathLength: f32=1.0f/cos_t;transmission_tint=pow(transmission_tint,vec3f(pathLength));\n#else\ntransmission_tint=transmission_color.rgb;\n#endif\n#endif\n#if defined(SUBSURFACE_SLAB) && defined(GEOMETRY_THIN_WALLED)\nlet unweighted_translucency: f32=max(mix(subsurface_weight,1.0f,transmission_weight),0.0001f);transmission_tint=mix(vec3f(1.0f),transmission_tint,transmission_weight/unweighted_translucency);transmission_roughness=mix(1.0f,transmission_roughness,transmission_weight/unweighted_translucency);\n#endif\nlet transmission_roughness_alpha: f32=transmission_roughnesstransmission_roughness;\n#endif\n#include<openpbrBackgroundTransmission>\nvar material_surface_ibl: vec3f=vec3f(0.f,0.f,0.f);\n#include<openpbrEnvironmentLighting>\nvar material_surface_direct: vec3f=vec3f(0.f,0.f,0.f);\n#if defined(LIGHT0)\nvar aggShadow: f32=0.f;\n#include<openpbrDirectLightingInit>[0..maxSimultaneousLights]\n#include<openpbrDirectLighting>[0..maxSimultaneousLights]\n#endif\nvar material_surface_emission: vec3f=uniforms.vEmissionColor;\n#ifdef EMISSION_COLOR\nlet emissionColorTex: vec3f=textureSample(emissionColorSampler,emissionColorSamplerSampler,fragmentInputs.vEmissionColorUV+uvOffset).rgb;\n#ifdef EMISSION_COLOR_GAMMA\nmaterial_surface_emission=toLinearSpaceVec3(emissionColorTex.rgb);\n#else\nmaterial_surface_emission=emissionColorTex.rgb;\n#endif\nmaterial_surface_emission= uniforms.vEmissionColorInfos.y;\n#endif\nmaterial_surface_emission=uniforms.vLightingIntensity.y;\n#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\nvar finalColor: vec4f=vec4f(material_surface_ibl+material_surface_direct+material_surface_emission,alpha);\n#define CUSTOM_FRAGMENT_BEFORE_FOG\nfinalColor=max(finalColor,vec4f(0.0));\n#include<logDepthFragment>\n#include<fogFragment>(color,finalColor)\n#include<pbrBlockImageProcessing>\n#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\n#ifdef PREPASS\n#include<openpbrBlockPrePass>\n#endif\n#if !defined(PREPASS) && !defined(ORDER_INDEPENDENT_TRANSPARENCY)\nfragmentOutputs.color=finalColor;\n#endif\n#include<oitFragment>\n#if ORDER_INDEPENDENT_TRANSPARENCY\nif (fragDepth==nearestDepth) {fragmentOutputs.frontColor=vec4f(fragmentOutputs.frontColor.rgb+finalColor.rgbfinalColor.aalphaMultiplier,1.0-alphaMultiplier(1.0-finalColor.a));} else {fragmentOutputs.backColor+=finalColor;}\n#endif\n#include<pbrDebug>\n#define CUSTOM_FRAGMENT_MAIN_END\n#endif\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, openpbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, openpbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, openpbrNormalMapFragmentMainFunctionsWGSL, openpbrNormalMapFragmentFunctionsWGSL, reflectionFunctionWGSL, openpbrDielectricReflectanceWGSL, openpbrConductorReflectanceWGSL, openpbrAmbientOcclusionFunctionsWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, openpbrVolumeFunctionsWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, openpbrNormalMapFragmentWGSL, openpbrBlockNormalFinalWGSL, openpbrBaseLayerDataWGSL, openpbrTransmissionLayerDataWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrCoatLayerDataWGSL, openpbrThinFilmLayerDataWGSL, openpbrFuzzLayerDataWGSL, openpbrAmbientOcclusionDataWGSL, depthPrePassWGSL, openpbrBackgroundTransmissionWGSL, openpbrEnvironmentLightingWGSL, openpbrDirectLightingInitWGSL, openpbrDirectLightingWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, openpbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/* @internal */\nexport const openpbrPixelShaderWGSL = { name, shader };\n"]}
1	+ {"version":3,"file":"openpbr.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/openpbr.fragment.ts"],"names":[],"mappings":"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","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { objectIdFunctionsWGSL } from \"./ShadersInclude/objectIdFunctions\";\nimport { prePassDeclarationWGSL } from \"./ShadersInclude/prePassDeclaration\";\nimport { oitDeclarationWGSL } from \"./ShadersInclude/oitDeclaration\";\nimport { sceneUboDeclarationWGSL } from \"./ShadersInclude/sceneUboDeclaration\";\nimport { meshUboDeclarationWGSL } from \"./ShadersInclude/meshUboDeclaration\";\nimport { openpbrUboDeclarationWGSL } from \"./ShadersInclude/openpbrUboDeclaration\";\nimport { mainUVVaryingDeclarationWGSL } from \"./ShadersInclude/mainUVVaryingDeclaration\";\nimport { pbrFragmentExtraDeclarationWGSL } from \"./ShadersInclude/pbrFragmentExtraDeclaration\";\nimport { lightUboDeclarationWGSL } from \"./ShadersInclude/lightUboDeclaration\";\nimport { samplerFragmentDeclarationWGSL } from \"./ShadersInclude/samplerFragmentDeclaration\";\nimport { pbrFragmentReflectionDeclarationWGSL } from \"./ShadersInclude/pbrFragmentReflectionDeclaration\";\nimport { openpbrFragmentSamplersDeclarationWGSL } from \"./ShadersInclude/openpbrFragmentSamplersDeclaration\";\nimport { imageProcessingDeclarationWGSL } from \"./ShadersInclude/imageProcessingDeclaration\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { fogFragmentDeclarationWGSL } from \"./ShadersInclude/fogFragmentDeclaration\";\nimport { textureRepetitionFunctionsWGSL } from \"./ShadersInclude/textureRepetitionFunctions\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { subSurfaceScatteringFunctionsWGSL } from \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport { importanceSamplingWGSL } from \"./ShadersInclude/importanceSampling\";\nimport { pbrHelperFunctionsWGSL } from \"./ShadersInclude/pbrHelperFunctions\";\nimport { imageProcessingFunctionsWGSL } from \"./ShadersInclude/imageProcessingFunctions\";\nimport { shadowsFragmentFunctionsWGSL } from \"./ShadersInclude/shadowsFragmentFunctions\";\nimport { harmonicsFunctionsWGSL } from \"./ShadersInclude/harmonicsFunctions\";\nimport { ltcHelperFunctionsWGSL } from \"./ShadersInclude/ltcHelperFunctions\";\nimport { pbrDirectLightingSetupFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingSetupFunctions\";\nimport { pbrDirectLightingFalloffFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingFalloffFunctions\";\nimport { pbrBRDFFunctionsWGSL } from \"./ShadersInclude/pbrBRDFFunctions\";\nimport { hdrFilteringFunctionsWGSL } from \"./ShadersInclude/hdrFilteringFunctions\";\nimport { clusteredLightingFunctionsWGSL } from \"./ShadersInclude/clusteredLightingFunctions\";\nimport { pbrBlockReflectance0WGSL } from \"./ShadersInclude/pbrBlockReflectance0\";\nimport { pbrClusteredLightingFunctionsWGSL } from \"./ShadersInclude/pbrClusteredLightingFunctions\";\nimport { pbrDirectLightingFunctionsWGSL } from \"./ShadersInclude/pbrDirectLightingFunctions\";\nimport { pbrIBLFunctionsWGSL } from \"./ShadersInclude/pbrIBLFunctions\";\nimport { openpbrNormalMapFragmentMainFunctionsWGSL } from \"./ShadersInclude/openpbrNormalMapFragmentMainFunctions\";\nimport { openpbrNormalMapFragmentFunctionsWGSL } from \"./ShadersInclude/openpbrNormalMapFragmentFunctions\";\nimport { reflectionFunctionWGSL } from \"./ShadersInclude/reflectionFunction\";\nimport { openpbrDielectricReflectanceWGSL } from \"./ShadersInclude/openpbrDielectricReflectance\";\nimport { openpbrConductorReflectanceWGSL } from \"./ShadersInclude/openpbrConductorReflectance\";\nimport { openpbrAmbientOcclusionFunctionsWGSL } from \"./ShadersInclude/openpbrAmbientOcclusionFunctions\";\nimport { openpbrGeometryInfoWGSL } from \"./ShadersInclude/openpbrGeometryInfo\";\nimport { openpbrIblFunctionsWGSL } from \"./ShadersInclude/openpbrIblFunctions\";\nimport { openpbrVolumeFunctionsWGSL } from \"./ShadersInclude/openpbrVolumeFunctions\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { pbrBlockNormalGeometricWGSL } from \"./ShadersInclude/pbrBlockNormalGeometric\";\nimport { openpbrNormalMapFragmentWGSL } from \"./ShadersInclude/openpbrNormalMapFragment\";\nimport { openpbrBlockNormalFinalWGSL } from \"./ShadersInclude/openpbrBlockNormalFinal\";\nimport { openpbrBaseLayerDataWGSL } from \"./ShadersInclude/openpbrBaseLayerData\";\nimport { openpbrTransmissionLayerDataWGSL } from \"./ShadersInclude/openpbrTransmissionLayerData\";\nimport { openpbrSubsurfaceLayerDataWGSL } from \"./ShadersInclude/openpbrSubsurfaceLayerData\";\nimport { openpbrCoatLayerDataWGSL } from \"./ShadersInclude/openpbrCoatLayerData\";\nimport { openpbrThinFilmLayerDataWGSL } from \"./ShadersInclude/openpbrThinFilmLayerData\";\nimport { openpbrFuzzLayerDataWGSL } from \"./ShadersInclude/openpbrFuzzLayerData\";\nimport { openpbrAmbientOcclusionDataWGSL } from \"./ShadersInclude/openpbrAmbientOcclusionData\";\nimport { depthPrePassWGSL } from \"./ShadersInclude/depthPrePass\";\nimport { openpbrBackgroundTransmissionWGSL } from \"./ShadersInclude/openpbrBackgroundTransmission\";\nimport { openpbrEnvironmentLightingWGSL } from \"./ShadersInclude/openpbrEnvironmentLighting\";\nimport { openpbrDirectLightingInitWGSL } from \"./ShadersInclude/openpbrDirectLightingInit\";\nimport { openpbrDirectLightingWGSL } from \"./ShadersInclude/openpbrDirectLighting\";\nimport { logDepthFragmentWGSL } from \"./ShadersInclude/logDepthFragment\";\nimport { fogFragmentWGSL } from \"./ShadersInclude/fogFragment\";\nimport { pbrBlockImageProcessingWGSL } from \"./ShadersInclude/pbrBlockImageProcessing\";\nimport { meshBlendTagFragmentOutputWGSL } from \"./ShadersInclude/meshBlendTagFragmentOutput\";\nimport { openpbrBlockPrePassWGSL } from \"./ShadersInclude/openpbrBlockPrePass\";\nimport { oitFragmentWGSL } from \"./ShadersInclude/oitFragment\";\nimport { pbrDebugWGSL } from \"./ShadersInclude/pbrDebug\";\n\nconst name = \"openpbrPixelShader\";\nconst shader = `#define OPENPBR_FRAGMENT_SHADER\n#define CUSTOM_FRAGMENT_BEGIN\n#include<prePassDeclaration>[SCENE_MRT_COUNT]\n#include<oitDeclaration>\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE\n#endif\n#include<openpbrUboDeclaration>\n#include<pbrFragmentExtraDeclaration>\n#include<lightUboDeclaration>[0..maxSimultaneousLights]\n#include<openpbrFragmentSamplersDeclaration>\n#include<imageProcessingDeclaration>\n#include<clipPlaneFragmentDeclaration>\n#include<logDepthDeclaration>\n#include<fogFragmentDeclaration>\n#include<textureRepetitionFunctions>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<importanceSampling>\n#include<pbrHelperFunctions>\n#include<imageProcessingFunctions>\n#include<shadowsFragmentFunctions>\n#include<harmonicsFunctions>\n#include<pbrDirectLightingSetupFunctions>\n#include<pbrDirectLightingFalloffFunctions>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\n#include<pbrDirectLightingFunctions>\n#include<pbrIBLFunctions>\n#include<openpbrNormalMapFragmentMainFunctions>\n#include<openpbrNormalMapFragmentFunctions>\n#ifdef REFLECTION\n#include<reflectionFunction>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\n#include<openpbrDielectricReflectance>\n#include<openpbrConductorReflectance>\n#include<openpbrAmbientOcclusionFunctions>\n#include<openpbrGeometryInfo>\n#include<openpbrIblFunctions>\n#include<openpbrVolumeFunctions>\nfn layer(slab_bottom: vec3f,slab_top: vec3f,lerp_factor: f32,bottom_multiplier: vec3f,top_multiplier: vec3f)->vec3f {return mix(slab_bottombottom_multiplier,slab_toptop_multiplier,lerp_factor);}\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#ifdef PREPASS_IRRADIANCE\nvar total_direct_diffuse: vec3f=vec3f(0.0f);\n#endif\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\n#include<pbrBlockNormalGeometric>\nvar coatNormalW: vec3f=normalW;\n#include<openpbrNormalMapFragment>\n#include<openpbrBlockNormalFinal>\n#include<openpbrBaseLayerData>\n#include<openpbrTransmissionLayerData>\n#include<openpbrSubsurfaceLayerData>\n#include<openpbrCoatLayerData>\n#include<openpbrThinFilmLayerData>\n#include<openpbrFuzzLayerData>\n#include<openpbrAmbientOcclusionData>\n#define CUSTOM_FRAGMENT_UPDATE_ALPHA\n#define DEPTHPREPASS_SKIP_EARLY_RETURN\n#include<depthPrePass>\n#ifndef DEPTHPREPASS\n#define CUSTOM_FRAGMENT_BEFORE_LIGHTS\n#ifdef ANISOTROPIC_COAT\nlet coatGeoInfo: geometryInfoAnisoOutParams=geometryInfoAniso(\ncoatNormalW,viewDirectionW.xyz,coat_roughness,geometricNormalW\n,vec3f(geometry_coat_tangent.x,geometry_coat_tangent.y,coat_roughness_anisotropy),TBN\n);\n#else\nlet coatGeoInfo: geometryInfoOutParams=geometryInfo(\ncoatNormalW,viewDirectionW.xyz,coat_roughness,geometricNormalW\n);\n#endif\nspecular_roughness=mix(specular_roughness,pow(min(1.0f,pow(specular_roughness,4.0f)+2.0fpow(coat_roughness,4.0f)),0.25f),coat_weight);\n#ifdef ANISOTROPIC_BASE\nlet baseGeoInfo: geometryInfoAnisoOutParams=geometryInfoAniso(\nnormalW,viewDirectionW.xyz,specular_roughness,geometricNormalW\n,vec3f(geometry_tangent.x,geometry_tangent.y,specular_roughness_anisotropy),TBN\n);\n#else\nlet baseGeoInfo: geometryInfoOutParams=geometryInfo(\nnormalW,viewDirectionW.xyz,specular_roughness,geometricNormalW\n);\n#endif\n#ifdef FUZZ\nlet fuzzNormalW=normalize(mix(normalW,coatNormalW,coat_weight));var fuzzTangent=normalize(TBN[0]);fuzzTangent=normalize(fuzzTangent-dot(fuzzTangent,fuzzNormalW)fuzzNormalW);let fuzzBitangent=cross(fuzzNormalW,fuzzTangent);let fuzzGeoInfo: geometryInfoOutParams=geometryInfo(\nfuzzNormalW,viewDirectionW.xyz,fuzz_roughness,geometricNormalW\n);\n#endif\nlet coatReflectance: ReflectanceParams=dielectricReflectance(\ncoat_ior \n,1.0f \n,vec3f(1.0f)\n,coat_weight\n);\n#ifdef THIN_FILM\nlet thin_film_outside_ior: f32=mix(1.0f,coat_ior,coat_weight);\n#endif\nlet baseDielectricReflectance: ReflectanceParams=dielectricReflectance(\nspecular_ior \n,mix(1.0f,coat_ior,coat_weight) \n,specular_color\n,specular_weight\n);let baseConductorReflectance: ReflectanceParams=conductorReflectance(base_color,specular_color,specular_weight);var volume_absorption: vec3f=vec3f(1.0f);var transmission_tint: vec3f=vec3f(1.0f);var surface_translucency_weight: f32=0.0f;\n#if defined(REFRACTED_BACKGROUND) \|\| defined(REFRACTED_ENVIRONMENT) \|\| defined(REFRACTED_LIGHTS)\n#if defined(GEOMETRY_THIN_WALLED)\nlet refractedViewVector: vec3f=-viewDirectionW;\n#else\n#ifdef DISPERSION\nvar refractedViewVectors: array<vec3f,3>;let iorDispersionSpread: f32=transmission_dispersion_scale/transmission_dispersion_abbe_number(specular_ior-1.0f);let dispersion_iors: vec3f=vec3f(specular_ior-iorDispersionSpread,specular_ior,specular_ior+iorDispersionSpread);for (var i: i32=0; i<3; i++) {refractedViewVectors[i]=double_refract(-viewDirectionW,normalW,dispersion_iors[i]); }\n#else\nlet refractedViewVector: vec3f=double_refract(-viewDirectionW,normalW,specular_ior);\n#endif\n#endif\n#ifdef GEOMETRY_THIN_WALLED\nvar transmission_roughness: f32=specular_roughness;\n#else\nvar transmission_roughness: f32=specular_roughnessclamp(4.0f(specular_ior-1.0f),0.001f,1.0f);\n#endif\n#if (defined(TRANSMISSION_SLAB) \|\| defined(SUBSURFACE_SLAB))\nvar volumeParams: OpenPBRHomogeneousVolume;{\n#if defined(TRANSMISSION_SLAB)\nlet transmissionVolumeParams: OpenPBRHomogeneousVolume=computeOpenPBRTransmissionVolume(\ntransmission_color.rgb,\ntransmission_depth,\ntransmission_scatter.rgb,\ntransmission_scatter_anisotropy\n);\n#endif\n#if defined(SUBSURFACE_SLAB)\nlet subsurfaceVolumeParams: OpenPBRHomogeneousVolume=computeOpenPBRSubsurfaceVolume(\nsubsurface_color.rgb,\nsubsurface_radius,\nsubsurface_radius_scale.rgb,\nsubsurface_scatter_anisotropy\n);\n#endif\n#if !defined(TRANSMISSION_SLAB)\nvolumeParams=subsurfaceVolumeParams;surface_translucency_weight=subsurface_weight;\n#elif !defined(SUBSURFACE_SLAB)\nvolumeParams=transmissionVolumeParams;\n#ifdef TRANSMISSION_SLAB_VOLUME\nvolumeParams.multi_scatter_color=singleScatterToMultiScatterAlbedo(volumeParams.ss_albedo);\n#endif\nsurface_translucency_weight=transmission_weight;\n#else\nlet subsurface_fraction_of_dielectric: f32=(1.0f-transmission_weight)subsurface_weight;let subsurface_and_transmission_fraction_of_dielectric: f32=subsurface_fraction_of_dielectric+transmission_weight;let reciprocal_of_subsurface_and_transmission_fraction_of_dielectric: f32 =\n1.0f/maxEps(subsurface_and_transmission_fraction_of_dielectric);let trans_weight: f32=transmission_weightreciprocal_of_subsurface_and_transmission_fraction_of_dielectric;let subsurf_weight: f32=subsurface_fraction_of_dielectricreciprocal_of_subsurface_and_transmission_fraction_of_dielectric;volumeParams.scatter_coeff=transmissionVolumeParams.scatter_coefftrans_weight+subsurfaceVolumeParams.scatter_coeffsubsurf_weight;volumeParams.absorption_coeff=transmissionVolumeParams.absorption_coefftrans_weight+subsurfaceVolumeParams.absorption_coeffsubsurf_weight;volumeParams.anisotropy=(transmissionVolumeParams.anisotropytrans_weight+subsurfaceVolumeParams.anisotropysubsurf_weight)/maxEps(trans_weight+subsurf_weight);volumeParams.extinction_coeff=volumeParams.absorption_coeff+volumeParams.scatter_coeff;volumeParams.ss_albedo=volumeParams.scatter_coeff/maxEpsVec3(volumeParams.extinction_coeff);volumeParams.multi_scatter_color=singleScatterToMultiScatterAlbedo(volumeParams.ss_albedo);surface_translucency_weight=subsurface_and_transmission_fraction_of_dielectric;\n#endif\n}\nvolume_absorption=exp(-volumeParams.absorption_coeffgeometry_thickness);var backscatter_color: vec3f=vec3f(1.0f);{let reduced_scatter: vec3f=volumeParams.scatter_coeffvec3f(1.0f-volumeParams.anisotropy);let reduced_albedo: vec3f=reduced_scatter/(volumeParams.absorption_coeff+reduced_scatter);let sqrt_term: vec3f=max(sqrt(vec3f(1.0f)-reduced_albedo),vec3f(0.0001f));backscatter_color=(vec3f(1.0f)-sqrt_term)/(vec3f(1.0f)+sqrt_term);}\n#elif defined(TRANSMISSION_SLAB)\nsurface_translucency_weight=transmission_weight;\n#endif\n#ifdef SCATTERING\n#ifdef GEOMETRY_THIN_WALLED\nvar iso_scatter_density: vec3f=vec3f(1.0f);\n#else\n#ifdef USE_IRRADIANCE_TEXTURE_FOR_SCATTERING\nlet mfp: vec3f=vec3f(100.0f)/volumeParams.extinction_coeff;var scattered_light_from_irradiance_texture: vec3f=sss_convolve(sceneIrradianceSampler,sceneDepthSampler,uniforms.renderTargetSize,mfp,scene.projection,scene.inverseProjection,SSS_SAMPLE_COUNT,noise.xy);var numLights=f32(LIGHTCOUNT);\n#ifdef REFLECTION\nnumLights+=1.0f;\n#endif\nscattered_light_from_irradiance_texture/=vec3f(numLights);\n#else\nlet scattered_light_from_irradiance_texture: vec3f=vec3f(0.0f);\n#endif\nlet back_to_iso_scattering_blend: f32=min(1.0f+volumeParams.anisotropy,1.0f);let iso_to_forward_scattering_blend: f32=max(volumeParams.anisotropy,0.0f);let iso_scatter_transmittance: vec3f=pow(exp(-volumeParams.scatter_coeffgeometry_thickness),vec3f(0.2f));var iso_scatter_density: vec3f=clamp(vec3f(1.0f)-iso_scatter_transmittance,vec3f(0.0f),vec3f(1.0f));transmission_roughness=min(transmission_roughness+pow((1.0f-abs(volumeParams.anisotropy))max3(iso_scatter_densityiso_scatter_density),3.0f),1.0f);\n#endif\nvolumeParams.multi_scatter_color=mix(volumeParams.ss_albedo,volumeParams.multi_scatter_color,max3(iso_scatter_density));\n#endif\n#if defined(TRANSMISSION_SLAB) && (!defined(TRANSMISSION_SLAB_VOLUME) \|\| defined(GEOMETRY_THIN_WALLED))\ntransmission_tint=transmission_color.rgb;\n#ifdef GEOMETRY_THIN_WALLED\nvar sin2: f32=1.0f-baseGeoInfo.NdotVbaseGeoInfo.NdotV;sin2=sin2/(specular_iorspecular_ior);let cos_t: f32=sqrt(1.0f-sin2);let pathLength: f32=1.0f/cos_t;transmission_tint=pow(transmission_tint,vec3f(pathLength));\n#else\ntransmission_tint=transmission_color.rgb;\n#endif\n#endif\n#if defined(SUBSURFACE_SLAB) && defined(GEOMETRY_THIN_WALLED)\nlet unweighted_translucency: f32=max(mix(subsurface_weight,1.0f,transmission_weight),0.0001f);transmission_tint=mix(vec3f(1.0f),transmission_tint,transmission_weight/unweighted_translucency);transmission_roughness=mix(1.0f,transmission_roughness,transmission_weight/unweighted_translucency);\n#endif\nlet transmission_roughness_alpha: f32=transmission_roughnesstransmission_roughness;\n#endif\n#include<openpbrBackgroundTransmission>\nvar material_surface_ibl: vec3f=vec3f(0.f,0.f,0.f);\n#include<openpbrEnvironmentLighting>\nvar material_surface_direct: vec3f=vec3f(0.f,0.f,0.f);\n#if defined(LIGHT0)\nvar aggShadow: f32=0.f;\n#include<openpbrDirectLightingInit>[0..maxSimultaneousLights]\n#include<openpbrDirectLighting>[0..maxSimultaneousLights]\n#endif\nvar material_surface_emission: vec3f=uniforms.vEmissionColor;\n#ifdef EMISSION_COLOR\nlet emissionColorTex: vec3f=textureSample(emissionColorSampler,emissionColorSamplerSampler,fragmentInputs.vEmissionColorUV+uvOffset).rgb;\n#ifdef EMISSION_COLOR_GAMMA\nmaterial_surface_emission=toLinearSpaceVec3(emissionColorTex.rgb);\n#else\nmaterial_surface_emission=emissionColorTex.rgb;\n#endif\nmaterial_surface_emission= uniforms.vEmissionColorInfos.y;\n#endif\nmaterial_surface_emission=uniforms.vLightingIntensity.y;\n#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\nvar finalColor: vec4f=vec4f(material_surface_ibl+material_surface_direct+material_surface_emission,alpha);\n#define CUSTOM_FRAGMENT_BEFORE_FOG\nfinalColor=max(finalColor,vec4f(0.0));\n#include<logDepthFragment>\n#include<fogFragment>(color,finalColor)\n#include<pbrBlockImageProcessing>\n#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\n#ifdef PREPASS\n#include<openpbrBlockPrePass>\n#endif\n#if !defined(PREPASS) && !defined(ORDER_INDEPENDENT_TRANSPARENCY)\nfragmentOutputs.color=finalColor;\n#endif\n#include<oitFragment>\n#if ORDER_INDEPENDENT_TRANSPARENCY\nif (fragDepth==nearestDepth) {fragmentOutputs.frontColor=vec4f(fragmentOutputs.frontColor.rgb+finalColor.rgbfinalColor.aalphaMultiplier,1.0-alphaMultiplier(1.0-finalColor.a));} else {fragmentOutputs.backColor+=finalColor;}\n#endif\n#include<pbrDebug>\n#define CUSTOM_FRAGMENT_MAIN_END\n#endif\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, openpbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, openpbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, openpbrNormalMapFragmentMainFunctionsWGSL, openpbrNormalMapFragmentFunctionsWGSL, reflectionFunctionWGSL, openpbrDielectricReflectanceWGSL, openpbrConductorReflectanceWGSL, openpbrAmbientOcclusionFunctionsWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, openpbrVolumeFunctionsWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, openpbrNormalMapFragmentWGSL, openpbrBlockNormalFinalWGSL, openpbrBaseLayerDataWGSL, openpbrTransmissionLayerDataWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrCoatLayerDataWGSL, openpbrThinFilmLayerDataWGSL, openpbrFuzzLayerDataWGSL, openpbrAmbientOcclusionDataWGSL, depthPrePassWGSL, openpbrBackgroundTransmissionWGSL, openpbrEnvironmentLightingWGSL, openpbrDirectLightingInitWGSL, openpbrDirectLightingWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, meshBlendTagFragmentOutputWGSL, openpbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/* @internal */\nexport const openpbrPixelShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/particles.fragment.js CHANGED Viewed

@@ -1,5 +1,7 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
+import { objectIdFunctionsWGSL } from "./ShadersInclude/objectIdFunctions.js";
+import { prePassDeclarationWGSL } from "./ShadersInclude/prePassDeclaration.js";
 import { clipPlaneFragmentDeclarationWGSL } from "./ShadersInclude/clipPlaneFragmentDeclaration.js";
 import { imageProcessingDeclarationWGSL } from "./ShadersInclude/imageProcessingDeclaration.js";
 import { logDepthDeclarationWGSL } from "./ShadersInclude/logDepthDeclaration.js";
@@ -9,8 +11,24 @@ import { fogFragmentDeclarationWGSL } from "./ShadersInclude/fogFragmentDeclarat
 import { clipPlaneFragmentWGSL } from "./ShadersInclude/clipPlaneFragment.js";
 import { logDepthFragmentWGSL } from "./ShadersInclude/logDepthFragment.js";
 import { fogFragmentWGSL } from "./ShadersInclude/fogFragment.js";
+import { meshBlendTagFragmentOutputWGSL } from "./ShadersInclude/meshBlendTagFragmentOutput.js";
+import { geometryRenderingFragmentWGSL } from "./ShadersInclude/geometryRenderingFragment.js";
 const name = "particlesPixelShader";
 const shader = `varying vUV: vec2f;varying vColor: vec4f;uniform textureMask: vec4f;var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+#ifdef PREPASS
+uniform geometryZeroAlphaDiscard: f32;
+#ifdef PREPASS_POSITION
+varying vGeometryPositionW: vec3f;
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+varying vGeometryNormalW: vec3f;
+#endif
+#ifdef PREPASS_NORMAL
+varying vGeometryNormalV: vec3f;
+#endif
+#endif
+#define PREPASS_VELOCITY_ZERO
+#include<prePassDeclaration>[SCENE_MRT_COUNT]
 #include<clipPlaneFragmentDeclaration>
 #include<imageProcessingDeclaration>
 #include<logDepthDeclaration>
@@ -26,6 +44,9 @@ fn main(input: FragmentInputs)->FragmentOutputs {
 #define CUSTOM_FRAGMENT_MAIN_BEGIN
 #include<clipPlaneFragment>
 var textureColor: vec4f=textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV);var baseColor: vec4f=(textureColor*uniforms.textureMask+( vec4f(1.,1.,1.,1.)-uniforms.textureMask))*input.vColor;
+#ifdef PREPASS
+let geometryAlbedo: vec3f=toLinearSpaceVec3(baseColor.rgb);
+#endif
 #ifdef RAMPGRADIENT
 var alpha: f32=baseColor.a;var remappedColorIndex: f32=clamp((alpha-input.remapRanges.x)/input.remapRanges.y,0.0,1.0);var rampColor: vec4f=textureSample(rampSampler,rampSamplerSampler,vec2f(1.0-remappedColorIndex,0.));baseColor=vec4f(baseColor.rgb*rampColor.rgb,baseColor.a);var finalAlpha: f32=baseColor.a;baseColor.a=clamp((alpha*rampColor.a-input.remapRanges.z)/input.remapRanges.w,0.0,1.0);
 #endif
@@ -41,14 +62,37 @@ baseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);
 baseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);baseColor=applyImageProcessing(baseColor);
 #endif
 #endif
+#ifdef PREPASS
+let geometryColor: vec4f=baseColor;if (geometryColor.a<=0.0 && uniforms.geometryZeroAlphaDiscard>0.0) {discard;}
+#ifdef PREPASS_POSITION
+let geometryPositionW: vec3f=input.vGeometryPositionW;
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+let geometryPositionL: vec3f=input.vPosition;
+#endif
+#ifdef PREPASS_DEPTH
+let geometryViewDepth: f32=input.vViewPos.z;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+let geometryNormalizedViewDepth: f32=input.vNormViewDepth;
+#endif
+#ifdef PREPASS_NORMAL
+let geometryNormalV: vec3f=normalize(input.vGeometryNormalV);
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+let geometryNormalW: vec3f=normalize(input.vGeometryNormalW);
+#endif
+#include<geometryRenderingFragment>
+#else
 fragmentOutputs.color=baseColor;
+#endif
 #define CUSTOM_FRAGMENT_MAIN_END
 }`;
 // Sideeffect
 if (!ShaderStore.ShadersStoreWGSL[name]) {
     ShaderStore.ShadersStoreWGSL[name] = shader;
 }
-const includes = [clipPlaneFragmentDeclarationWGSL, imageProcessingDeclarationWGSL, logDepthDeclarationWGSL, helperFunctionsWGSL, imageProcessingFunctionsWGSL, fogFragmentDeclarationWGSL, clipPlaneFragmentWGSL, logDepthFragmentWGSL, fogFragmentWGSL];
+const includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, imageProcessingDeclarationWGSL, logDepthDeclarationWGSL, helperFunctionsWGSL, imageProcessingFunctionsWGSL, fogFragmentDeclarationWGSL, clipPlaneFragmentWGSL, logDepthFragmentWGSL, fogFragmentWGSL, meshBlendTagFragmentOutputWGSL, geometryRenderingFragmentWGSL];
 for (const inc of includes) {
     if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
         ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;

package/ShadersWGSL/particles.fragment.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particles.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/particles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;~~AAE~~/D,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCb~~,CAAC;AACH,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,gCAAgC,EAAE,8BAA8B,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,4BAA4B,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,eAAe,CAAC,CAAC;~~AAC1P~~,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { imageProcessingDeclarationWGSL } from \"./ShadersInclude/imageProcessingDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { imageProcessingFunctionsWGSL } from \"./ShadersInclude/imageProcessingFunctions\";\nimport { fogFragmentDeclarationWGSL } from \"./ShadersInclude/fogFragmentDeclaration\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { logDepthFragmentWGSL } from \"./ShadersInclude/logDepthFragment\";\nimport { fogFragmentWGSL } from \"./ShadersInclude/fogFragment\";\n\nconst name = \"particlesPixelShader\";\nconst shader = `varying vUV: vec2f;varying vColor: vec4f;uniform textureMask: vec4f;var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;\n#include<clipPlaneFragmentDeclaration>\n#include<imageProcessingDeclaration>\n#include<logDepthDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\n#ifdef RAMPGRADIENT\nvarying remapRanges: vec4f;var rampSamplerSampler: sampler;var rampSampler: texture_2d<f32>;\n#endif\n#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvar textureColor: vec4f=textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV);var baseColor: vec4f=(textureColoruniforms.textureMask+( vec4f(1.,1.,1.,1.)-uniforms.textureMask))input.vColor;\n#ifdef RAMPGRADIENT\nvar alpha: f32=baseColor.a;var remappedColorIndex: f32=clamp((alpha-input.remapRanges.x)/input.remapRanges.y,0.0,1.0);var rampColor: vec4f=textureSample(rampSampler,rampSamplerSampler,vec2f(1.0-remappedColorIndex,0.));baseColor=vec4f(baseColor.rgbrampColor.rgb,baseColor.a);var finalAlpha: f32=baseColor.a;baseColor.a=clamp((alpharampColor.a-input.remapRanges.z)/input.remapRanges.w,0.0,1.0);\n#endif\n#ifdef BLENDMULTIPLYMODE\nvar sourceAlpha: f32=input.vColor.atextureColor.a;baseColor=vec4f(baseColor.rgbsourceAlpha+ vec3f(1.0)(1.0-sourceAlpha),baseColor.a);\n#endif\n#include<logDepthFragment>\n#include<fogFragment>(color,baseColor)\n#ifdef IMAGEPROCESSINGPOSTPROCESS\nbaseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);\n#else\n#ifdef IMAGEPROCESSING\nbaseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);baseColor=applyImageProcessing(baseColor);\n#endif\n#endif\nfragmentOutputs.color=baseColor;\n#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [clipPlaneFragmentDeclarationWGSL, imageProcessingDeclarationWGSL, logDepthDeclarationWGSL, helperFunctionsWGSL, imageProcessingFunctionsWGSL, fogFragmentDeclarationWGSL, clipPlaneFragmentWGSL, logDepthFragmentWGSL, fogFragmentWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/* @internal */\nexport const particlesPixelShaderWGSL = { name, shader };\n"]}
1	+ {"version":3,"file":"particles.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/particles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,4BAA4B,EAAE,MAAM,2CAA2C,CAAC;AACzF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAE3F,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyEb,CAAC;AACH,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,qBAAqB,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,8BAA8B,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,4BAA4B,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,eAAe,EAAE,8BAA8B,EAAE,6BAA6B,CAAC,CAAC;AACxW,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { objectIdFunctionsWGSL } from \"./ShadersInclude/objectIdFunctions\";\nimport { prePassDeclarationWGSL } from \"./ShadersInclude/prePassDeclaration\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { imageProcessingDeclarationWGSL } from \"./ShadersInclude/imageProcessingDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { imageProcessingFunctionsWGSL } from \"./ShadersInclude/imageProcessingFunctions\";\nimport { fogFragmentDeclarationWGSL } from \"./ShadersInclude/fogFragmentDeclaration\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { logDepthFragmentWGSL } from \"./ShadersInclude/logDepthFragment\";\nimport { fogFragmentWGSL } from \"./ShadersInclude/fogFragment\";\nimport { meshBlendTagFragmentOutputWGSL } from \"./ShadersInclude/meshBlendTagFragmentOutput\";\nimport { geometryRenderingFragmentWGSL } from \"./ShadersInclude/geometryRenderingFragment\";\n\nconst name = \"particlesPixelShader\";\nconst shader = `varying vUV: vec2f;varying vColor: vec4f;uniform textureMask: vec4f;var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;\n#ifdef PREPASS\nuniform geometryZeroAlphaDiscard: f32;\n#ifdef PREPASS_POSITION\nvarying vGeometryPositionW: vec3f;\n#endif\n#ifdef PREPASS_WORLD_NORMAL\nvarying vGeometryNormalW: vec3f;\n#endif\n#ifdef PREPASS_NORMAL\nvarying vGeometryNormalV: vec3f;\n#endif\n#endif\n#define PREPASS_VELOCITY_ZERO\n#include<prePassDeclaration>[SCENE_MRT_COUNT]\n#include<clipPlaneFragmentDeclaration>\n#include<imageProcessingDeclaration>\n#include<logDepthDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\n#ifdef RAMPGRADIENT\nvarying remapRanges: vec4f;var rampSamplerSampler: sampler;var rampSampler: texture_2d<f32>;\n#endif\n#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvar textureColor: vec4f=textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV);var baseColor: vec4f=(textureColoruniforms.textureMask+( vec4f(1.,1.,1.,1.)-uniforms.textureMask))input.vColor;\n#ifdef PREPASS\nlet geometryAlbedo: vec3f=toLinearSpaceVec3(baseColor.rgb);\n#endif\n#ifdef RAMPGRADIENT\nvar alpha: f32=baseColor.a;var remappedColorIndex: f32=clamp((alpha-input.remapRanges.x)/input.remapRanges.y,0.0,1.0);var rampColor: vec4f=textureSample(rampSampler,rampSamplerSampler,vec2f(1.0-remappedColorIndex,0.));baseColor=vec4f(baseColor.rgbrampColor.rgb,baseColor.a);var finalAlpha: f32=baseColor.a;baseColor.a=clamp((alpharampColor.a-input.remapRanges.z)/input.remapRanges.w,0.0,1.0);\n#endif\n#ifdef BLENDMULTIPLYMODE\nvar sourceAlpha: f32=input.vColor.atextureColor.a;baseColor=vec4f(baseColor.rgbsourceAlpha+ vec3f(1.0)(1.0-sourceAlpha),baseColor.a);\n#endif\n#include<logDepthFragment>\n#include<fogFragment>(color,baseColor)\n#ifdef IMAGEPROCESSINGPOSTPROCESS\nbaseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);\n#else\n#ifdef IMAGEPROCESSING\nbaseColor=vec4f(toLinearSpaceVec3(baseColor.rgb),baseColor.a);baseColor=applyImageProcessing(baseColor);\n#endif\n#endif\n#ifdef PREPASS\nlet geometryColor: vec4f=baseColor;if (geometryColor.a<=0.0 && uniforms.geometryZeroAlphaDiscard>0.0) {discard;}\n#ifdef PREPASS_POSITION\nlet geometryPositionW: vec3f=input.vGeometryPositionW;\n#endif\n#ifdef PREPASS_LOCAL_POSITION\nlet geometryPositionL: vec3f=input.vPosition;\n#endif\n#ifdef PREPASS_DEPTH\nlet geometryViewDepth: f32=input.vViewPos.z;\n#endif\n#ifdef PREPASS_NORMALIZED_VIEW_DEPTH\nlet geometryNormalizedViewDepth: f32=input.vNormViewDepth;\n#endif\n#ifdef PREPASS_NORMAL\nlet geometryNormalV: vec3f=normalize(input.vGeometryNormalV);\n#endif\n#ifdef PREPASS_WORLD_NORMAL\nlet geometryNormalW: vec3f=normalize(input.vGeometryNormalW);\n#endif\n#include<geometryRenderingFragment>\n#else\nfragmentOutputs.color=baseColor;\n#endif\n#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, imageProcessingDeclarationWGSL, logDepthDeclarationWGSL, helperFunctionsWGSL, imageProcessingFunctionsWGSL, fogFragmentDeclarationWGSL, clipPlaneFragmentWGSL, logDepthFragmentWGSL, fogFragmentWGSL, meshBlendTagFragmentOutputWGSL, geometryRenderingFragmentWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/* @internal */\nexport const particlesPixelShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/particles.vertex.js CHANGED Viewed

@@ -21,6 +21,30 @@ attribute direction: vec3f;
 attribute remapData: vec4f;
 #endif
 attribute offset: vec2f;uniform view: mat4x4f;uniform projection: mat4x4f;uniform translationPivot: vec2f;
+#ifdef PREPASS
+uniform cameraInfo: vec2f;
+#if defined(LOCAL) && defined(PREPASS_LOCAL_POSITION)
+uniform inverseEmitterWM: mat4x4f;uniform geometryWorldOffset: vec3f;
+#endif
+#ifdef PREPASS_POSITION
+varying vGeometryPositionW: vec3f;
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+varying vGeometryNormalW: vec3f;
+#endif
+#ifdef PREPASS_NORMAL
+varying vGeometryNormalV: vec3f;
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+varying vPosition: vec3f;
+#endif
+#ifdef PREPASS_DEPTH
+varying vViewPos: vec3f;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+varying vNormViewDepth: f32;
+#endif
+#endif
 #ifdef ANIMATESHEET
 uniform particlesInfos: vec3f;
 #endif
@@ -49,27 +73,53 @@ var row1: vec3f=normalize(vertexInputs.direction);
 var crossProduct: vec3f=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));var row1: vec3f= vec3f(crossProduct.x,crossProduct.y,crossProduct.z);
 #endif
 var rotMatrix: mat3x3f= mat3x3f(row0,row1,row2);var alignedCorner: vec3f=rotMatrix*rotatedCorner;return vertexInputs.position+alignedCorner;}
+fn stretchedNormal(toCamera: vec3f,stretchDirection: vec3f)->vec3f {let normalizedToCamera: vec3f=normalize(toCamera);let normalizedCrossDirToCamera: vec3f=normalize(cross(normalize(stretchDirection),normalizedToCamera));
+#ifdef BILLBOARDSTRETCHED_LOCAL
+let row1: vec3f=normalize(stretchDirection);
+#else
+let row1: vec3f=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));
+#endif
+return normalize(cross(normalizedCrossDirToCamera,row1));}
 #endif
 #define CUSTOM_VERTEX_DEFINITIONS
 @vertex
 fn main(input : VertexInputs)->FragmentInputs {
 #define CUSTOM_VERTEX_MAIN_BEGIN
-var cornerPos: vec2f;var vPositionW: vec3f;cornerPos=( vec2f(vertexInputs.offset.x-0.5,vertexInputs.offset.y -0.5)-uniforms.translationPivot)*vertexInputs.size;
+var cornerPos: vec2f;var vPositionW: vec3f;
+#ifdef PREPASS
+var geometryNormalW: vec3f;
+#endif
+cornerPos=( vec2f(vertexInputs.offset.x-0.5,vertexInputs.offset.y -0.5)-uniforms.translationPivot)*vertexInputs.size;
 #ifdef BILLBOARD
 var rotatedCorner: vec3f;
 #ifdef BILLBOARDY
-rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=vertexInputs.position-uniforms.eyePosition;yaxis.y=0.;vPositionW=rotate(normalize(yaxis),rotatedCorner);var viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;
+rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=vertexInputs.position-uniforms.eyePosition;yaxis.y=0.;vPositionW=rotate(normalize(yaxis),rotatedCorner);
+#ifdef PREPASS
+geometryNormalW=normalize(yaxis);
+#endif
+var viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;
 #elif defined(BILLBOARDSTRETCHED)
-rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var toCamera: vec3f=vertexInputs.position-uniforms.eyePosition;vPositionW=rotateAlign(toCamera,rotatedCorner);var viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;
+rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var toCamera: vec3f=vertexInputs.position-uniforms.eyePosition;vPositionW=rotateAlign(toCamera,rotatedCorner);
+#ifdef PREPASS
+geometryNormalW=stretchedNormal(toCamera,vertexInputs.direction);
+#endif
+var viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;
 #else
 rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var viewPos: vec3f=(uniforms.view* vec4f(vertexInputs.position,1.0)).xyz+rotatedCorner;vPositionW=(uniforms.invView* vec4f(viewPos,1)).xyz;
+#ifdef PREPASS
+geometryNormalW=normalize((uniforms.invView*vec4f(0.0,0.0,1.0,0.0)).xyz);
+#endif
 #endif
 #ifdef RAMPGRADIENT
 vertexOutputs.remapRanges=vertexInputs.remapData;
 #endif
 vertexOutputs.position=uniforms.projection* vec4f(viewPos,1.0);
 #else
-var rotatedCorner: vec3f;rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=normalize(vertexInputs.direction);vPositionW=rotate(yaxis,rotatedCorner);vertexOutputs.position=uniforms.projection*uniforms.view* vec4f(vPositionW,1.0);
+var rotatedCorner: vec3f;rotatedCorner.x=cornerPos.x*cos(vertexInputs.angle)-cornerPos.y*sin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.x*sin(vertexInputs.angle)+cornerPos.y*cos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=normalize(vertexInputs.direction);vPositionW=rotate(yaxis,rotatedCorner);
+#ifdef PREPASS
+geometryNormalW=yaxis;
+#endif
+vertexOutputs.position=uniforms.projection*uniforms.view* vec4f(vPositionW,1.0);
 #endif
 vertexOutputs.vColor=vertexInputs.color;
 #ifdef ANIMATESHEET
@@ -86,6 +136,38 @@ vertexOutputs.vPositionW=vPositionW;
 #include<clipPlaneVertex>
 #include<fogVertex>
 #include<logDepthVertex>
+#ifdef PREPASS
+let geometryViewPosition: vec4f=uniforms.view*vec4f(vPositionW,1.0);
+#if defined(PREPASS_NORMAL) || defined(PREPASS_WORLD_NORMAL)
+var geometryNormalV=normalize((uniforms.view*vec4f(geometryNormalW,0.0)).xyz);let geometryViewDirection=select(vec3f(0.0,0.0,geometryViewPosition.z),geometryViewPosition.xyz,uniforms.projection[3][3]==0.0);if (dot(geometryNormalV,geometryViewDirection)>0.0) {geometryNormalV=-geometryNormalV;geometryNormalW=-geometryNormalW;}
+#endif
+#ifdef PREPASS_POSITION
+vertexOutputs.vGeometryPositionW=vPositionW;
+#endif
+#ifdef PREPASS_WORLD_NORMAL
+vertexOutputs.vGeometryNormalW=normalize(geometryNormalW);
+#endif
+#ifdef PREPASS_NORMAL
+vertexOutputs.vGeometryNormalV=geometryNormalV;
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+#ifdef LOCAL
+var geometryRenderPosition=vPositionW;
+#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)
+geometryRenderPosition=vertexInputs.position+(uniforms.invView*vec4f(rotatedCorner,0.0)).xyz;
+#endif
+vertexOutputs.vPosition=(uniforms.inverseEmitterWM*vec4f(geometryRenderPosition-uniforms.geometryWorldOffset,1.0)).xyz;
+#else
+vertexOutputs.vPosition=vPositionW;
+#endif
+#endif
+#ifdef PREPASS_DEPTH
+vertexOutputs.vViewPos=geometryViewPosition.xyz;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+vertexOutputs.vNormViewDepth=(geometryViewPosition.z-uniforms.cameraInfo.x)/(uniforms.cameraInfo.y-uniforms.cameraInfo.x);
+#endif
+#endif
 #define CUSTOM_VERTEX_MAIN_END
 }`;
 // Sideeffect

package/ShadersWGSL/particles.vertex.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"particles.vertex.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/particles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgFb,CAAC;AACH,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,8BAA8B,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;AAC7J,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { clipPlaneVertexDeclarationWGSL } from \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport { fogVertexDeclarationWGSL } from \"./ShadersInclude/fogVertexDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { clipPlaneVertexWGSL } from \"./ShadersInclude/clipPlaneVertex\";\nimport { fogVertexWGSL } from \"./ShadersInclude/fogVertex\";\nimport { logDepthVertexWGSL } from \"./ShadersInclude/logDepthVertex\";\n\nconst name = \"particlesVertexShader\";\nconst shader = `attribute position: vec3f;attribute color: vec4f;attribute angle: f32;attribute size: vec2f;\n#ifdef ANIMATESHEET\nattribute cellIndex: f32;\n#endif\n#ifndef BILLBOARD\nattribute direction: vec3f;\n#endif\n#ifdef BILLBOARDSTRETCHED\nattribute direction: vec3f;\n#endif\n#ifdef RAMPGRADIENT\nattribute remapData: vec4f;\n#endif\nattribute offset: vec2f;uniform view: mat4x4f;uniform projection: mat4x4f;uniform translationPivot: vec2f;\n#ifdef ANIMATESHEET\nuniform particlesInfos: vec3f; \n#endif\nvarying vUV: vec2f;varying vColor: vec4f;\n#ifdef POSITIONW_AS_VARYING\nvarying vPositionW: vec3f;\n#endif\n#ifdef RAMPGRADIENT\nvarying remapRanges: vec4f;\n#endif\n#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform invView: mat4x4f;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<logDepthDeclaration>\n#ifdef BILLBOARD\nuniform eyePosition: vec3f;\n#endif\nfn rotate(yaxis: vec3f,rotatedCorner: vec3f)->vec3f {var xaxis: vec3f=normalize(cross( vec3f(0.,1.0,0.),yaxis));var zaxis: vec3f=normalize(cross(yaxis,xaxis));var row0: vec3f= vec3f(xaxis.x,xaxis.y,xaxis.z);var row1: vec3f= vec3f(yaxis.x,yaxis.y,yaxis.z);var row2: vec3f= vec3f(zaxis.x,zaxis.y,zaxis.z);var rotMatrix: mat3x3f= mat3x3f(row0,row1,row2);var alignedCorner: vec3f=rotMatrixrotatedCorner;return vertexInputs.position+alignedCorner;}\n#ifdef BILLBOARDSTRETCHED\nfn rotateAlign(toCamera: vec3f,rotatedCorner: vec3f)->vec3f {var normalizedToCamera: vec3f=normalize(toCamera);var normalizedCrossDirToCamera: vec3f=normalize(cross(normalize(vertexInputs.direction),normalizedToCamera));var row0: vec3f= vec3f(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);var row2: vec3f= vec3f(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\n#ifdef BILLBOARDSTRETCHED_LOCAL\nvar row1: vec3f=normalize(vertexInputs.direction);\n#else\nvar crossProduct: vec3f=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));var row1: vec3f= vec3f(crossProduct.x,crossProduct.y,crossProduct.z);\n#endif\nvar rotMatrix: mat3x3f= mat3x3f(row0,row1,row2);var alignedCorner: vec3f=rotMatrixrotatedCorner;return vertexInputs.position+alignedCorner;}\n#endif\n#define CUSTOM_VERTEX_DEFINITIONS\n@vertex\nfn main(input : VertexInputs)->FragmentInputs {\n#define CUSTOM_VERTEX_MAIN_BEGIN\nvar cornerPos: vec2f;var vPositionW: vec3f;cornerPos=( vec2f(vertexInputs.offset.x-0.5,vertexInputs.offset.y -0.5)-uniforms.translationPivot)vertexInputs.size;\n#ifdef BILLBOARD\nvar rotatedCorner: vec3f;\n#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=vertexInputs.position-uniforms.eyePosition;yaxis.y=0.;vPositionW=rotate(normalize(yaxis),rotatedCorner);var viewPos: vec3f=(uniforms.view vec4f(vPositionW,1.0)).xyz;\n#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var toCamera: vec3f=vertexInputs.position-uniforms.eyePosition;vPositionW=rotateAlign(toCamera,rotatedCorner);var viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;\n#else\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var viewPos: vec3f=(uniforms.view* vec4f(vertexInputs.position,1.0)).xyz+rotatedCorner;vPositionW=(uniforms.invView* vec4f(viewPos,1)).xyz;\n#endif\n#ifdef RAMPGRADIENT\nvertexOutputs.remapRanges=vertexInputs.remapData;\n#endif\nvertexOutputs.position=uniforms.projection* vec4f(viewPos,1.0);\n#else\nvar rotatedCorner: vec3f;rotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=normalize(vertexInputs.direction);vPositionW=rotate(yaxis,rotatedCorner);vertexOutputs.position=uniforms.projectionuniforms.view vec4f(vPositionW,1.0);\n#endif\nvertexOutputs.vColor=vertexInputs.color;\n#ifdef ANIMATESHEET\nvar rowOffset: f32=floor(vertexInputs.cellIndexuniforms.particlesInfos.z);var columnOffset: f32=vertexInputs.cellIndex-rowOffset/uniforms.particlesInfos.z;var uvScale: vec2f=uniforms.particlesInfos.xy;var uvOffset: vec2f= vec2f(vertexInputs.offset.x ,1.0-vertexInputs.offset.y);vertexOutputs.vUV=(uvOffset+ vec2f(columnOffset,rowOffset))uvScale;\n#else\nvertexOutputs.vUV=vertexInputs.offset;\n#endif\n#if defined(CLIPPLANE) \|\| defined(CLIPPLANE2) \|\| defined(CLIPPLANE3) \|\| defined(CLIPPLANE4) \|\| defined(CLIPPLANE5) \|\| defined(CLIPPLANE6) \|\| defined(FOG)\nvar worldPos: vec4f= vec4f(vPositionW,1.0);\n#endif\n#ifdef POSITIONW_AS_VARYING\nvertexOutputs.vPositionW=vPositionW;\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<logDepthVertex>\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [clipPlaneVertexDeclarationWGSL, fogVertexDeclarationWGSL, logDepthDeclarationWGSL, clipPlaneVertexWGSL, fogVertexWGSL, logDepthVertexWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/** @internal */\nexport const particlesVertexShaderWGSL = { name, shader };\n"]}
1	+ {"version":3,"file":"particles.vertex.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/particles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkKb,CAAC;AACH,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,8BAA8B,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;AAC7J,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { clipPlaneVertexDeclarationWGSL } from \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport { fogVertexDeclarationWGSL } from \"./ShadersInclude/fogVertexDeclaration\";\nimport { logDepthDeclarationWGSL } from \"./ShadersInclude/logDepthDeclaration\";\nimport { clipPlaneVertexWGSL } from \"./ShadersInclude/clipPlaneVertex\";\nimport { fogVertexWGSL } from \"./ShadersInclude/fogVertex\";\nimport { logDepthVertexWGSL } from \"./ShadersInclude/logDepthVertex\";\n\nconst name = \"particlesVertexShader\";\nconst shader = `attribute position: vec3f;attribute color: vec4f;attribute angle: f32;attribute size: vec2f;\n#ifdef ANIMATESHEET\nattribute cellIndex: f32;\n#endif\n#ifndef BILLBOARD\nattribute direction: vec3f;\n#endif\n#ifdef BILLBOARDSTRETCHED\nattribute direction: vec3f;\n#endif\n#ifdef RAMPGRADIENT\nattribute remapData: vec4f;\n#endif\nattribute offset: vec2f;uniform view: mat4x4f;uniform projection: mat4x4f;uniform translationPivot: vec2f;\n#ifdef PREPASS\nuniform cameraInfo: vec2f;\n#if defined(LOCAL) && defined(PREPASS_LOCAL_POSITION)\nuniform inverseEmitterWM: mat4x4f;uniform geometryWorldOffset: vec3f;\n#endif\n#ifdef PREPASS_POSITION\nvarying vGeometryPositionW: vec3f;\n#endif\n#ifdef PREPASS_WORLD_NORMAL\nvarying vGeometryNormalW: vec3f;\n#endif\n#ifdef PREPASS_NORMAL\nvarying vGeometryNormalV: vec3f;\n#endif\n#ifdef PREPASS_LOCAL_POSITION\nvarying vPosition: vec3f;\n#endif\n#ifdef PREPASS_DEPTH\nvarying vViewPos: vec3f;\n#endif\n#ifdef PREPASS_NORMALIZED_VIEW_DEPTH\nvarying vNormViewDepth: f32;\n#endif\n#endif\n#ifdef ANIMATESHEET\nuniform particlesInfos: vec3f; \n#endif\nvarying vUV: vec2f;varying vColor: vec4f;\n#ifdef POSITIONW_AS_VARYING\nvarying vPositionW: vec3f;\n#endif\n#ifdef RAMPGRADIENT\nvarying remapRanges: vec4f;\n#endif\n#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform invView: mat4x4f;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<logDepthDeclaration>\n#ifdef BILLBOARD\nuniform eyePosition: vec3f;\n#endif\nfn rotate(yaxis: vec3f,rotatedCorner: vec3f)->vec3f {var xaxis: vec3f=normalize(cross( vec3f(0.,1.0,0.),yaxis));var zaxis: vec3f=normalize(cross(yaxis,xaxis));var row0: vec3f= vec3f(xaxis.x,xaxis.y,xaxis.z);var row1: vec3f= vec3f(yaxis.x,yaxis.y,yaxis.z);var row2: vec3f= vec3f(zaxis.x,zaxis.y,zaxis.z);var rotMatrix: mat3x3f= mat3x3f(row0,row1,row2);var alignedCorner: vec3f=rotMatrixrotatedCorner;return vertexInputs.position+alignedCorner;}\n#ifdef BILLBOARDSTRETCHED\nfn rotateAlign(toCamera: vec3f,rotatedCorner: vec3f)->vec3f {var normalizedToCamera: vec3f=normalize(toCamera);var normalizedCrossDirToCamera: vec3f=normalize(cross(normalize(vertexInputs.direction),normalizedToCamera));var row0: vec3f= vec3f(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);var row2: vec3f= vec3f(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\n#ifdef BILLBOARDSTRETCHED_LOCAL\nvar row1: vec3f=normalize(vertexInputs.direction);\n#else\nvar crossProduct: vec3f=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));var row1: vec3f= vec3f(crossProduct.x,crossProduct.y,crossProduct.z);\n#endif\nvar rotMatrix: mat3x3f= mat3x3f(row0,row1,row2);var alignedCorner: vec3f=rotMatrixrotatedCorner;return vertexInputs.position+alignedCorner;}\nfn stretchedNormal(toCamera: vec3f,stretchDirection: vec3f)->vec3f {let normalizedToCamera: vec3f=normalize(toCamera);let normalizedCrossDirToCamera: vec3f=normalize(cross(normalize(stretchDirection),normalizedToCamera));\n#ifdef BILLBOARDSTRETCHED_LOCAL\nlet row1: vec3f=normalize(stretchDirection);\n#else\nlet row1: vec3f=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));\n#endif\nreturn normalize(cross(normalizedCrossDirToCamera,row1));}\n#endif\n#define CUSTOM_VERTEX_DEFINITIONS\n@vertex\nfn main(input : VertexInputs)->FragmentInputs {\n#define CUSTOM_VERTEX_MAIN_BEGIN\nvar cornerPos: vec2f;var vPositionW: vec3f;\n#ifdef PREPASS\nvar geometryNormalW: vec3f;\n#endif\ncornerPos=( vec2f(vertexInputs.offset.x-0.5,vertexInputs.offset.y -0.5)-uniforms.translationPivot)vertexInputs.size;\n#ifdef BILLBOARD\nvar rotatedCorner: vec3f;\n#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=vertexInputs.position-uniforms.eyePosition;yaxis.y=0.;vPositionW=rotate(normalize(yaxis),rotatedCorner);\n#ifdef PREPASS\ngeometryNormalW=normalize(yaxis);\n#endif\nvar viewPos: vec3f=(uniforms.view vec4f(vPositionW,1.0)).xyz;\n#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var toCamera: vec3f=vertexInputs.position-uniforms.eyePosition;vPositionW=rotateAlign(toCamera,rotatedCorner);\n#ifdef PREPASS\ngeometryNormalW=stretchedNormal(toCamera,vertexInputs.direction);\n#endif\nvar viewPos: vec3f=(uniforms.view* vec4f(vPositionW,1.0)).xyz;\n#else\nrotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.y=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.z=0.;var viewPos: vec3f=(uniforms.view* vec4f(vertexInputs.position,1.0)).xyz+rotatedCorner;vPositionW=(uniforms.invView* vec4f(viewPos,1)).xyz;\n#ifdef PREPASS\ngeometryNormalW=normalize((uniforms.invViewvec4f(0.0,0.0,1.0,0.0)).xyz);\n#endif\n#endif\n#ifdef RAMPGRADIENT\nvertexOutputs.remapRanges=vertexInputs.remapData;\n#endif\nvertexOutputs.position=uniforms.projection vec4f(viewPos,1.0);\n#else\nvar rotatedCorner: vec3f;rotatedCorner.x=cornerPos.xcos(vertexInputs.angle)-cornerPos.ysin(vertexInputs.angle)+uniforms.translationPivot.x;rotatedCorner.z=cornerPos.xsin(vertexInputs.angle)+cornerPos.ycos(vertexInputs.angle)+uniforms.translationPivot.y;rotatedCorner.y=0.;var yaxis: vec3f=normalize(vertexInputs.direction);vPositionW=rotate(yaxis,rotatedCorner);\n#ifdef PREPASS\ngeometryNormalW=yaxis;\n#endif\nvertexOutputs.position=uniforms.projectionuniforms.view vec4f(vPositionW,1.0);\n#endif\nvertexOutputs.vColor=vertexInputs.color;\n#ifdef ANIMATESHEET\nvar rowOffset: f32=floor(vertexInputs.cellIndexuniforms.particlesInfos.z);var columnOffset: f32=vertexInputs.cellIndex-rowOffset/uniforms.particlesInfos.z;var uvScale: vec2f=uniforms.particlesInfos.xy;var uvOffset: vec2f= vec2f(vertexInputs.offset.x ,1.0-vertexInputs.offset.y);vertexOutputs.vUV=(uvOffset+ vec2f(columnOffset,rowOffset))uvScale;\n#else\nvertexOutputs.vUV=vertexInputs.offset;\n#endif\n#if defined(CLIPPLANE) \|\| defined(CLIPPLANE2) \|\| defined(CLIPPLANE3) \|\| defined(CLIPPLANE4) \|\| defined(CLIPPLANE5) \|\| defined(CLIPPLANE6) \|\| defined(FOG)\nvar worldPos: vec4f= vec4f(vPositionW,1.0);\n#endif\n#ifdef POSITIONW_AS_VARYING\nvertexOutputs.vPositionW=vPositionW;\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<logDepthVertex>\n#ifdef PREPASS\nlet geometryViewPosition: vec4f=uniforms.viewvec4f(vPositionW,1.0);\n#if defined(PREPASS_NORMAL) \|\| defined(PREPASS_WORLD_NORMAL)\nvar geometryNormalV=normalize((uniforms.viewvec4f(geometryNormalW,0.0)).xyz);let geometryViewDirection=select(vec3f(0.0,0.0,geometryViewPosition.z),geometryViewPosition.xyz,uniforms.projection[3][3]==0.0);if (dot(geometryNormalV,geometryViewDirection)>0.0) {geometryNormalV=-geometryNormalV;geometryNormalW=-geometryNormalW;}\n#endif\n#ifdef PREPASS_POSITION\nvertexOutputs.vGeometryPositionW=vPositionW;\n#endif\n#ifdef PREPASS_WORLD_NORMAL\nvertexOutputs.vGeometryNormalW=normalize(geometryNormalW);\n#endif\n#ifdef PREPASS_NORMAL\nvertexOutputs.vGeometryNormalV=geometryNormalV;\n#endif\n#ifdef PREPASS_LOCAL_POSITION\n#ifdef LOCAL\nvar geometryRenderPosition=vPositionW;\n#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\ngeometryRenderPosition=vertexInputs.position+(uniforms.invViewvec4f(rotatedCorner,0.0)).xyz;\n#endif\nvertexOutputs.vPosition=(uniforms.inverseEmitterWMvec4f(geometryRenderPosition-uniforms.geometryWorldOffset,1.0)).xyz;\n#else\nvertexOutputs.vPosition=vPositionW;\n#endif\n#endif\n#ifdef PREPASS_DEPTH\nvertexOutputs.vViewPos=geometryViewPosition.xyz;\n#endif\n#ifdef PREPASS_NORMALIZED_VIEW_DEPTH\nvertexOutputs.vNormViewDepth=(geometryViewPosition.z-uniforms.cameraInfo.x)/(uniforms.cameraInfo.y-uniforms.cameraInfo.x);\n#endif\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [clipPlaneVertexDeclarationWGSL, fogVertexDeclarationWGSL, logDepthDeclarationWGSL, clipPlaneVertexWGSL, fogVertexWGSL, logDepthVertexWGSL];\nfor (const inc of includes) {\n if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n }\n}\n\n/** @internal */\nexport const particlesVertexShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/pbr.fragment.js CHANGED Viewed

@@ -65,6 +65,7 @@ import { pbrBlockFinalColorCompositionWGSL } from "./ShadersInclude/pbrBlockFina
 import { logDepthFragmentWGSL } from "./ShadersInclude/logDepthFragment.js";
 import { fogFragmentWGSL } from "./ShadersInclude/fogFragment.js";
 import { pbrBlockImageProcessingWGSL } from "./ShadersInclude/pbrBlockImageProcessing.js";
+import { meshBlendTagFragmentOutputWGSL } from "./ShadersInclude/meshBlendTagFragmentOutput.js";
 import { pbrBlockPrePassWGSL } from "./ShadersInclude/pbrBlockPrePass.js";
 import { oitFragmentWGSL } from "./ShadersInclude/oitFragment.js";
 import { pbrDebugWGSL } from "./ShadersInclude/pbrDebug.js";
@@ -642,7 +643,7 @@ if (fragDepth==nearestDepth) {fragmentOutputs.frontColor=vec4f(fragmentOutputs.f
 if (!ShaderStore.ShadersStoreWGSL[name]) {
     ShaderStore.ShadersStoreWGSL[name] = shader;
 }
-const includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, pbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, samplerFragmentAlternateDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, pbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, bumpFragmentMainFunctionsWGSL, bumpFragmentFunctionsWGSL, reflectionFunctionWGSL, decalFragmentWGSL, pbrBlockAlbedoOpacityWGSL, pbrBlockReflectivityWGSL, pbrBlockAmbientOcclusionWGSL, pbrBlockAlphaFresnelWGSL, pbrBlockAnisotropicWGSL, pbrBlockReflectionWGSL, pbrBlockSheenWGSL, pbrBlockClearcoatWGSL, pbrBlockIridescenceWGSL, pbrBlockSubSurfaceWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, bumpFragmentWGSL, pbrBlockNormalFinalWGSL, depthPrePassWGSL, pbrBlockLightmapInitWGSL, pbrBlockGeometryInfoWGSL, pbrBlockReflectanceWGSL, pbrBlockDirectLightingWGSL, lightFragmentWGSL, pbrBlockFinalLitComponentsWGSL, pbrBlockFinalUnlitComponentsWGSL, pbrBlockFinalColorCompositionWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, pbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];
+const includes = [objectIdFunctionsWGSL, prePassDeclarationWGSL, oitDeclarationWGSL, sceneUboDeclarationWGSL, meshUboDeclarationWGSL, pbrUboDeclarationWGSL, mainUVVaryingDeclarationWGSL, pbrFragmentExtraDeclarationWGSL, lightUboDeclarationWGSL, samplerFragmentDeclarationWGSL, samplerFragmentAlternateDeclarationWGSL, pbrFragmentReflectionDeclarationWGSL, pbrFragmentSamplersDeclarationWGSL, imageProcessingDeclarationWGSL, clipPlaneFragmentDeclarationWGSL, logDepthDeclarationWGSL, fogFragmentDeclarationWGSL, textureRepetitionFunctionsWGSL, helperFunctionsWGSL, subSurfaceScatteringFunctionsWGSL, importanceSamplingWGSL, pbrHelperFunctionsWGSL, imageProcessingFunctionsWGSL, shadowsFragmentFunctionsWGSL, harmonicsFunctionsWGSL, ltcHelperFunctionsWGSL, pbrDirectLightingSetupFunctionsWGSL, pbrDirectLightingFalloffFunctionsWGSL, pbrBRDFFunctionsWGSL, hdrFilteringFunctionsWGSL, clusteredLightingFunctionsWGSL, pbrBlockReflectance0WGSL, pbrClusteredLightingFunctionsWGSL, pbrDirectLightingFunctionsWGSL, pbrIBLFunctionsWGSL, bumpFragmentMainFunctionsWGSL, bumpFragmentFunctionsWGSL, reflectionFunctionWGSL, decalFragmentWGSL, pbrBlockAlbedoOpacityWGSL, pbrBlockReflectivityWGSL, pbrBlockAmbientOcclusionWGSL, pbrBlockAlphaFresnelWGSL, pbrBlockAnisotropicWGSL, pbrBlockReflectionWGSL, pbrBlockSheenWGSL, pbrBlockClearcoatWGSL, pbrBlockIridescenceWGSL, pbrBlockSubSurfaceWGSL, clipPlaneFragmentWGSL, pbrBlockNormalGeometricWGSL, bumpFragmentWGSL, pbrBlockNormalFinalWGSL, depthPrePassWGSL, pbrBlockLightmapInitWGSL, pbrBlockGeometryInfoWGSL, pbrBlockReflectanceWGSL, pbrBlockDirectLightingWGSL, lightFragmentWGSL, pbrBlockFinalLitComponentsWGSL, pbrBlockFinalUnlitComponentsWGSL, pbrBlockFinalColorCompositionWGSL, logDepthFragmentWGSL, fogFragmentWGSL, pbrBlockImageProcessingWGSL, meshBlendTagFragmentOutputWGSL, pbrBlockPrePassWGSL, oitFragmentWGSL, pbrDebugWGSL];
 for (const inc of includes) {
     if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
         ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;