pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/surface-motion.js

@@ -0,0 +1,84 @@
+const MAX_FLOAT = 3.4028234663852886e38;
+function fail(code, label) {
+    throw new Error("TC_SURFACE_MOTION_" +
+        code +
+        ": " +
+        label +
+        "; re-extract unique version 1 surfaces and supply a complete current order");
+}
+function identity(t, label) {
+    if (!t ||
+        typeof t.objectUuid !== "string" ||
+        !t.objectUuid.length ||
+        typeof t.geometryUuid !== "string" ||
+        !t.geometryUuid.length ||
+        ![t.instanceId, t.elementOffset].every((n) => Number.isSafeInteger(n) && n >= 0) ||
+        !Number.isSafeInteger(t.groupIndex) ||
+        t.groupIndex < -1 ||
+        !Array.isArray(t.vertexIndices) ||
+        t.vertexIndices.length !== 3 ||
+        !Array.from(t.vertexIndices).every((n) => Number.isSafeInteger(n) && n >= 0))
+        fail("INVALID_IDENTITY", label);
+    // Keep exactly the geometry identity used by acceleration.ts, not material UUID.
+    return JSON.stringify([
+        t.objectUuid,
+        t.geometryUuid,
+        t.instanceId,
+        t.groupIndex,
+        t.elementOffset,
+        t.vertexIndices,
+    ]);
+}
+function index(scene, label, positions) {
+    if (!scene ||
+        scene.version !== 1 ||
+        !Array.isArray(scene.triangles) ||
+        !Array.isArray(scene.materials) ||
+        !Array.isArray(scene.textures) ||
+        !Array.isArray(scene.diagnostics))
+        fail("INVALID_SNAPSHOT", label);
+    const triangles = new Map();
+    for (const [i, t] of scene.triangles.entries()) {
+        const location = label + ".triangles[" + i + "]";
+        const key = identity(t, location);
+        if (triangles.has(key))
+            fail("DUPLICATE_IDENTITY", location);
+        if (positions) {
+            if (!Array.isArray(t.vertices) || t.vertices.length !== 3)
+                fail("INVALID_POSITION", location + ".vertices");
+            for (const [j, v] of t.vertices.entries()) {
+                const p = v?.position;
+                if (!Array.isArray(p) ||
+                    p.length !== 3 ||
+                    !Array.from(p).every((n) => typeof n === "number" &&
+                        Number.isFinite(n) &&
+                        Math.abs(n) <= MAX_FLOAT))
+                    fail("INVALID_POSITION", location + ".vertices[" + j + "].position");
+            }
+        }
+        triangles.set(key, t);
+    }
+    return triangles;
+}
+/** Previous world-space positions only; a match does not validate shading history. */
+export function packPreviousSurfacePositions(previous, current, ordered = current?.triangles) {
+    const remaining = index(current, "current", false);
+    const history = previous === undefined ? undefined : index(previous, "previous", true);
+    if (!Array.isArray(ordered) || ordered.length !== remaining.size)
+        fail("INVALID_ORDER", "ordered must include every current triangle once");
+    const data = new Float32Array(ordered.length * 12);
+    let matched = 0;
+    for (const [i, t] of ordered.entries()) {
+        const key = identity(t, "ordered[" + i + "]");
+        if (!remaining.delete(key))
+            fail("INVALID_ORDER", "ordered[" + i + "] is unknown or repeated");
+        const old = history?.get(key);
+        if (!old)
+            continue;
+        for (let j = 0; j < 3; j++)
+            data.set(old.vertices[j].position, i * 12 + j * 4);
+        data[i * 12 + 3] = 1;
+        matched++;
+    }
+    return { data, matched, missing: ordered.length - matched };
+}

package/lib/renderer/surface-ray-shader.js

@@ -0,0 +1,91 @@
+/** Surface storage bindings 0..3, dynamic acceleration nodes at 4. Caller normalizes ray direction. */
+export const SURFACE_RAY_SHADER = /* wgsl */ String.raw `
+override surfaceOrderedTraversal:bool=false;
+struct SurfaceNode{lo:vec4f,hi:vec4f,}
+struct SurfaceHit{distance:f32,index:i32,bary:vec3f,front:bool,}
+struct SurfaceCursor{current:u32,previous:u32,}
+@group(0) @binding(4) var<storage,read> surfaceAccelerationData:array<vec4f>;
+fn surfaceLoadNode(index:u32)->SurfaceNode{return SurfaceNode(surfaceAccelerationData[index*2u],surfaceAccelerationData[index*2u+1u]);}
+fn surfaceBox(origin:vec3f,direction:vec3f,node:SurfaceNode,maxDistance:f32)->bool{
+ var near=0.0;var far=maxDistance;
+ for(var axis=0u;axis<3u;axis++){
+  if(abs(direction[axis])<1e-20){if(origin[axis]<node.lo[axis]||origin[axis]>node.hi[axis]){return false;}}
+  else{let a=(node.lo[axis]-origin[axis])/direction[axis];let b=(node.hi[axis]-origin[axis])/direction[axis];near=max(near,min(a,b));far=min(far,max(a,b));if(near>far){return false;}}
+ }return far>=near;
+}
+fn surfaceEntry(origin:vec3f,direction:vec3f,inverse:vec3f,node:SurfaceNode,maxDistance:f32)->f32{
+ let parallel=abs(direction)<vec3f(1e-20);if(any(parallel&((origin<node.lo.xyz)|(origin>node.hi.xyz)))){return 1e30;}
+ let a=(node.lo.xyz-origin)*inverse;let b=(node.hi.xyz-origin)*inverse;let low=min(a,b);let high=max(a,b);let near=max(max(low.x,low.y),max(low.z,0.0));let far=min(min(high.x,high.y),min(high.z,maxDistance));return select(1e30,near,near<=far);
+}
+// Shared-edge predicates use the same sheared endpoint products in either winding.
+fn surfaceBoundary(origin:vec3f,direction:vec3f,a:vec3f,b:vec3f,c:vec3f,maxDistance:f32)->vec4f{
+ var kz=0u;if(abs(direction.y)>abs(direction.x)){kz=1u;}if(abs(direction.z)>abs(direction[kz])){kz=2u;}
+ var kx=(kz+1u)%3u;var ky=(kx+1u)%3u;if(direction[kz]<0.0){let swap=kx;kx=ky;ky=swap;}
+ let relativeA=a-origin;let relativeB=b-origin;let relativeC=c-origin;
+ let sx=direction[kx]/direction[kz];let sy=direction[ky]/direction[kz];
+ let pa=vec2f(relativeA[kx]-sx*relativeA[kz],relativeA[ky]-sy*relativeA[kz]);
+ let pb=vec2f(relativeB[kx]-sx*relativeB[kz],relativeB[ky]-sy*relativeB[kz]);
+ let pc=vec2f(relativeC[kx]-sx*relativeC[kz],relativeC[ky]-sy*relativeC[kz]);
+ let edges=vec3f(pb.x*pc.y-pb.y*pc.x,pc.x*pa.y-pc.y*pa.x,pa.x*pb.y-pa.y*pb.x);
+ if(any(edges<vec3f(0))&&any(edges>vec3f(0))){return vec4f(0,0,0,-1);}
+ let determinant=edges.x+edges.y+edges.z;if(determinant==0.0){return vec4f(0,0,0,-1);}
+ let distance=dot(edges,vec3f(relativeA[kz],relativeB[kz],relativeC[kz]))/(determinant*direction[kz]);
+ if(distance<=0.0||distance>maxDistance){return vec4f(0,0,0,-1);}
+ return vec4f(edges/determinant,distance);
+}
+// Parent links permit near-first descent without a fixed per-ray traversal stack.
+fn surfaceNextLeaf(origin:vec3f,direction:vec3f,inverse:vec3f,limit:f32,nodeCount:u32,triangleCount:u32,cursor:ptr<function,SurfaceCursor>)->u32{
+ loop{
+  let current=(*cursor).current;if(current>=nodeCount){return nodeCount;}
+  let node=surfaceLoadNode(current);
+  let links=surfaceAccelerationData[nodeCount*2u+triangleCount*3u+current];let parent=u32(links.x);
+  if(current==0u&&(*cursor).previous==nodeCount&&surfaceEntry(origin,direction,inverse,node,limit)==1e30){(*cursor).current=nodeCount;return nodeCount;}
+  if(node.hi.w>0.0){(*cursor).previous=current;(*cursor).current=parent;return current;}
+  let left=u32(links.y);let right=u32(links.z);
+  let leftEntry=surfaceEntry(origin,direction,inverse,surfaceLoadNode(left),1e30);
+  let rightEntry=surfaceEntry(origin,direction,inverse,surfaceLoadNode(right),1e30);
+  let first=select(left,right,rightEntry<leftEntry);let second=select(right,left,rightEntry<leftEntry);
+  let near= min(leftEntry,rightEntry);let far=max(leftEntry,rightEntry);
+  var next=parent;
+  if((*cursor).previous==parent&&near<1e30&&near<=limit){next=first;}
+  else if(((*cursor).previous==parent||(*cursor).previous==first)&&far<1e30&&far<=limit){next=second;}
+  (*cursor).previous=current;(*cursor).current=next;
+ }
+}
+fn traceSurface(origin:vec3f,direction:vec3f,maxDistance:f32,nodeCount:u32,triangleCount:u32,coverageRandom:f32)->SurfaceHit{
+ var hit=SurfaceHit(maxDistance,-1,vec3f(0),true);if(nodeCount==0u||triangleCount==0u){return hit;}
+ let inverse=1.0/select(vec3f(1e-30),direction,abs(direction)>vec3f(1e-20));var current=0u;var cursor=SurfaceCursor(0u,nodeCount);
+ loop{if(surfaceOrderedTraversal){current=surfaceNextLeaf(origin,direction,inverse,hit.distance,nodeCount,triangleCount,&cursor);}if(current>=nodeCount){break;}let node=surfaceLoadNode(current);if(!surfaceOrderedTraversal&&surfaceEntry(origin,direction,inverse,node,hit.distance)==1e30){current=select(u32(node.lo.w),current+1u,node.hi.w>0.0);continue;}
+  if(node.hi.w>0.0){let start=u32(node.lo.w);let count=u32(node.hi.w);
+   for(var slot=0u;slot<count;slot++){
+    let index=start+slot;if(index>=triangleCount){continue;}let offset=nodeCount*2u+index*3u;let a=surfaceAccelerationData[offset];let packedB=surfaceAccelerationData[offset+1u];let b=packedB.xyz;let c=surfaceAccelerationData[offset+2u].xyz;let edge1=b-a.xyz;let edge2=c-a.xyz;let p=cross(direction,edge2);let determinant=dot(edge1,p);let material=surfaceMaterials[u32(a.w)];let epsilon=1e-7*length(edge1)*length(edge2);if(determinant==0.0||((!surfacePhysicalEnabled||material.physical.x==0.0)&&abs(determinant)<=epsilon)){continue;}
+    let front=(determinant>0.0)==(packedB.w>0.0);if((!surfacePhysicalEnabled||material.physical.x==0.0)&&((material.maps1.w==0.0&&!front)||(material.maps1.w==1.0&&front))){continue;}
+    var distance:f32;var bary:vec3f;if((surfacePhysicalEnabled&&material.physical.x>0.0)){let boundary=surfaceBoundary(origin,direction,a.xyz,b,c,hit.distance);if(boundary.w<0.0){continue;}distance=boundary.w;bary=boundary.xyz;}else{let inverse=1.0/determinant;let relative=origin-a.xyz;let u=dot(relative,p)*inverse;if(u<0.0||u>1.0){continue;}let q=cross(relative,edge1);let v=dot(direction,q)*inverse;if(v<0.0||u+v>1.0){continue;}distance=dot(edge2,q)*inverse;if(distance<=1e-5||distance>hit.distance){continue;}bary=vec3f(1.0-u-v,u,v);}
+    let coverage=surfaceCoverage(index,bary,front);
+    if(coverage.y>0.5||(material.normal.w==2.0&&surfaceCoverageRandom(coverageRandom,index)>coverage.x)){continue;}
+    if(distance==hit.distance&&hit.index>=0&&index>=u32(hit.index)){continue;}
+    hit=SurfaceHit(distance,i32(index),bary,front);
+   }
+  }
+ current++;
+ }return hit;
+}
+fn occludedSurface(origin:vec3f,direction:vec3f,maxDistance:f32,nodeCount:u32,triangleCount:u32,coverageRandom:f32)->bool{
+ var hit=SurfaceHit(maxDistance,-1,vec3f(0),true);if(nodeCount==0u||triangleCount==0u){return false;}
+ let inverse=1.0/select(vec3f(1e-30),direction,abs(direction)>vec3f(1e-20));var current=0u;
+ loop{if(current>=nodeCount){break;}let node=surfaceLoadNode(current);if(surfaceEntry(origin,direction,inverse,node,hit.distance)==1e30){current=select(u32(node.lo.w),current+1u,node.hi.w>0.0);continue;}
+  if(node.hi.w>0.0){let start=u32(node.lo.w);let count=u32(node.hi.w);
+   for(var slot=0u;slot<count;slot++){
+    let index=start+slot;if(index>=triangleCount){continue;}let offset=nodeCount*2u+index*3u;let a=surfaceAccelerationData[offset];let packedB=surfaceAccelerationData[offset+1u];let b=packedB.xyz;let c=surfaceAccelerationData[offset+2u].xyz;let edge1=b-a.xyz;let edge2=c-a.xyz;let p=cross(direction,edge2);let determinant=dot(edge1,p);let material=surfaceMaterials[u32(a.w)];let epsilon=1e-7*length(edge1)*length(edge2);if(determinant==0.0||((!surfacePhysicalEnabled||material.physical.x==0.0)&&abs(determinant)<=epsilon)){continue;}
+    let front=(determinant>0.0)==(packedB.w>0.0);if((!surfacePhysicalEnabled||material.physical.x==0.0)&&((material.maps1.w==0.0&&!front)||(material.maps1.w==1.0&&front))){continue;}
+    var distance:f32;var bary:vec3f;if((surfacePhysicalEnabled&&material.physical.x>0.0)){let boundary=surfaceBoundary(origin,direction,a.xyz,b,c,hit.distance);if(boundary.w<0.0){continue;}distance=boundary.w;bary=boundary.xyz;}else{let inverse=1.0/determinant;let relative=origin-a.xyz;let u=dot(relative,p)*inverse;if(u<0.0||u>1.0){continue;}let q=cross(relative,edge1);let v=dot(direction,q)*inverse;if(v<0.0||u+v>1.0){continue;}distance=dot(edge2,q)*inverse;if(distance<=1e-5||distance>hit.distance){continue;}bary=vec3f(1.0-u-v,u,v);}
+    let coverage=surfaceCoverage(index,bary,front);
+    if(coverage.y>0.5||(material.normal.w==2.0&&surfaceCoverageRandom(coverageRandom,index)>coverage.x)){continue;}
+    if(distance==hit.distance&&hit.index>=0&&index>=u32(hit.index)){continue;}
+    return true;
+   }
+  }
+ current++;
+ }return false;
+}
+`;

package/lib/renderer/surface-shader.js

@@ -0,0 +1,88 @@
+/** Shared shader surface evaluator. Bindings 0..3 match surface-gpu ABI 1. */
+import { DEFAULT_SURFACE_GRAPHS } from "./material-graphs.js";
+export const SURFACE_SHADER = /* wgsl */ String.raw `
+override surfacePhysicalEnabled:bool=true;
+struct SurfaceTriangle {
+ a:vec4f,b:vec4f,c:vec4f,na:vec4f,nb:vec4f,nc:vec4f,
+ ua:vec4f,ub:vec4f,uc:vec4f,ca:vec4f,cb:vec4f,cc:vec4f,
+ ta:vec4f,tb:vec4f,tc:vec4f,nma:vec4f,nmb:vec4f,nmc:vec4f,
+}
+struct SurfaceMaterial {base:vec4f,factors:vec4f,emission:vec4f,maps0:vec4f,maps1:vec4f,normal:vec4f,physical:vec4f,attenuation:vec4f,}
+struct SurfaceTexture {info:vec4u,modes:vec4u,m0:vec4f,m1:vec4f,m2:vec4f,options:vec4f,}
+struct SurfaceValue {base:vec3f,alpha:f32,normal:vec3f,roughness:f32,emissive:vec3f,metalness:f32,ao:f32,discarded:u32,medium:vec4f,specular:vec4f,}
+fn surfaceCoverageRandom(random:f32,index:u32)->f32{var value=bitcast<u32>(random)^(index*0x9e3779b9u+0x85ebca6bu);value=(value^(value>>16u))*0x7feb352du;value=(value^(value>>15u))*0x846ca68bu;value=value^(value>>16u);return min(f32(value)/4294967296.0,0.99999994);}
+fn surfaceOriginalFront(triangle:SurfaceTriangle,geometricFront:bool)->bool{return geometricFront==(triangle.nma.w>0.0);}
+fn surfaceNormalSign(material:SurfaceMaterial,front:bool)->f32{return select(1.0,-1.0,select(material.maps1.w==1.0||(material.maps1.w==2.0&&!front),!front,surfacePhysicalEnabled&&material.physical.x>0.0));}
+fn surfaceGraphNormal(value:vec3f,fallback:vec3f)->vec3f{let scale=max(max(abs(value.x),abs(value.y)),abs(value.z));if(scale==0.0){return fallback;}return normalize(value/scale);}
+@group(0) @binding(0) var<storage,read> surfaceGeometry:array<vec4f>;
+fn surfaceTriangle(index:u32)->SurfaceTriangle{
+ let p=index*18u;return SurfaceTriangle(surfaceGeometry[p],surfaceGeometry[p+1u],surfaceGeometry[p+2u],surfaceGeometry[p+3u],surfaceGeometry[p+4u],surfaceGeometry[p+5u],surfaceGeometry[p+6u],surfaceGeometry[p+7u],surfaceGeometry[p+8u],surfaceGeometry[p+9u],surfaceGeometry[p+10u],surfaceGeometry[p+11u],surfaceGeometry[p+12u],surfaceGeometry[p+13u],surfaceGeometry[p+14u],surfaceGeometry[p+15u],surfaceGeometry[p+16u],surfaceGeometry[p+17u]);
+}
+@group(0) @binding(1) var<storage,read> surfaceMaterials:array<SurfaceMaterial>;
+@group(0) @binding(2) var<storage,read> surfaceTextures:array<SurfaceTexture>;
+@group(0) @binding(3) var<storage,read> surfaceTexels:array<u32>;
+fn surfaceSrgb(value:vec3f)->vec3f {return select(pow((value+vec3f(0.055))/1.055,vec3f(2.4)),value/12.92,value<=vec3f(0.04045));}
+fn surfaceIndex(value:i32,size:i32,mode:u32)->i32{
+ if(mode==0u){return clamp(value,0,size-1);}
+ if(mode==1u){return ((value%size)+size)%size;}
+ let period=size*2;let index=((value%period)+period)%period;return select(period-1-index,index,index<size);
+}
+fn surfaceRead(texture:SurfaceTexture,x:i32,y:i32)->vec4f{
+ let index=u32(surfaceIndex(y,i32(texture.info.z),texture.modes.y))*texture.info.y+u32(surfaceIndex(x,i32(texture.info.y),texture.modes.x));
+ var value:vec4f;
+ if((texture.modes.w&1u)!=0u){let offset=texture.info.x+index*4u;value=vec4f(bitcast<f32>(surfaceTexels[offset]),bitcast<f32>(surfaceTexels[offset+1u]),bitcast<f32>(surfaceTexels[offset+2u]),bitcast<f32>(surfaceTexels[offset+3u]));}
+ else{value=unpack4x8unorm(surfaceTexels[texture.info.x+index]);}
+ if((texture.modes.w&2u)!=0u){value=vec4f(surfaceSrgb(value.rgb),value.a);}return value;
+}
+fn surfaceUV(texture:SurfaceTexture,uvs:vec4f)->vec2f{
+ let uv=select(uvs.xy,uvs.zw,texture.info.w==1u);return (mat3x3f(texture.m0.xyz,texture.m1.xyz,texture.m2.xyz)*vec3f(uv,1)).xy;
+}
+fn surfaceWrap(value:f32,mode:u32)->f32{
+ if(mode==0u){return clamp(value,0.0,1.0);}if(mode==1u){return fract(value);}let p=value-floor(value/2.0)*2.0;return select(2.0-p,p,p<=1.0);
+}
+fn surfaceCoverage(index:u32,bary:vec3f,front:bool)->vec2f{
+ let material=surfaceMaterials[u32(surfaceTriangle(index).a.w)];
+ if((!surfacePhysicalEnabled||material.physical.x==0.0)&&((material.maps1.w==0.0&&!front)||(material.maps1.w==1.0&&front))){return vec2f(0,1);}
+ if(material.normal.w==0.0&&material.factors.z==0.0){return vec2f(1,0);}
+ let triangle=surfaceTriangle(index);
+ let uv=triangle.ua*bary.x+triangle.ub*bary.y+triangle.uc*bary.z;var alpha=material.base.a;
+ if(triangle.nb.w>0.5){alpha*=triangle.ca.a*bary.x+triangle.cb.a*bary.y+triangle.cc.a*bary.z;}
+ alpha*=surfaceMap(material.maps0.x,uv).a*surfaceMap(material.maps0.y,uv).g;
+ let custom=surfaceGraphOpacity(index,bary,front);if(custom.y>0.5){alpha*=custom.x;}
+ return vec2f(alpha,select(0.0,1.0,material.factors.z>0.0&&alpha<=material.factors.z));
+}
+fn surfaceMap(id:f32,uvs:vec4f)->vec4f{
+ if(id<0.0){return vec4f(1);}let texture=surfaceTextures[u32(id)];let uv=surfaceUV(texture,uvs);let coordinate=vec2f(surfaceWrap(uv.x,texture.modes.x),surfaceWrap(uv.y,texture.modes.y))*vec2f(texture.info.yz);
+ if(texture.modes.z==0u){let pixel=vec2i(floor(coordinate));return surfaceRead(texture,pixel.x,pixel.y);}
+ let at=coordinate-vec2f(0.5);let pixel=vec2i(floor(at));let blend=fract(at);return mix(mix(surfaceRead(texture,pixel.x,pixel.y),surfaceRead(texture,pixel.x+1,pixel.y),blend.x),mix(surfaceRead(texture,pixel.x,pixel.y+1),surfaceRead(texture,pixel.x+1,pixel.y+1),blend.x),blend.y);
+}
+fn evaluateSurface(index:u32,bary:vec3f,front:bool)->SurfaceValue{
+ return evaluateSurfaceView(index,bary,front,vec3f(0));
+}
+fn evaluateSurfaceView(index:u32,bary:vec3f,front:bool,view:vec3f)->SurfaceValue{
+ let triangle=surfaceTriangle(index);let material=surfaceMaterials[u32(triangle.a.w)];let uv=triangle.ua*bary.x+triangle.ub*bary.y+triangle.uc*bary.z;
+ let reverse=select(material.maps1.w==1.0||(material.maps1.w==2.0&&!front),!front,(surfacePhysicalEnabled&&material.physical.x>0.0));let sign=select(1.0,-1.0,reverse);
+ var normal=normalize(triangle.na.xyz*bary.x+triangle.nb.xyz*bary.y+triangle.nc.xyz*bary.z)*sign;
+ var color=material.base;if(triangle.nb.w>0.5){color*=triangle.ca*bary.x+triangle.cb*bary.y+triangle.cc*bary.z;}
+ color*=vec4f(triangle.b.w,triangle.c.w,triangle.na.w,1);color*=surfaceMap(material.maps0.x,uv);color.a*=surfaceMap(material.maps0.y,uv).g;
+ let roughness=material.factors.x*surfaceMap(material.maps0.w,uv).g;let metalness=material.factors.y*surfaceMap(material.maps1.x,uv).b;
+ let ao=1.0+(surfaceMap(material.maps1.y,uv).r-1.0)*material.factors.w;let emissive=material.emission.rgb*material.emission.w*surfaceMap(material.maps1.z,uv).rgb;
+ if(material.maps0.z>=0.0){
+  let texture=surfaceTextures[u32(material.maps0.z)];var sampled=surfaceMap(material.maps0.z,uv).xyz*2.0-vec3f(1);sampled=vec3f(sampled.xy*material.normal.xy,sampled.z);
+  if(material.normal.z>0.5){normal=normalize(mat3x3f(triangle.nma.xyz,triangle.nmb.xyz,triangle.nmc.xyz)*sampled*sign);}
+  else{
+   var tangent:vec3f;var handedness:f32;
+   if(triangle.nc.w>0.5){let t=triangle.ta*bary.x+triangle.tb*bary.y+triangle.tc*bary.z;tangent=normalize(t.xyz)*sign;handedness=select(-1.0,1.0,t.w>=0.0);}
+   else{let a=surfaceUV(texture,triangle.ua);let b=surfaceUV(texture,triangle.ub);let c=surfaceUV(texture,triangle.uc);let du1=b-a;let du2=c-a;let det=du1.x*du2.y-du2.x*du1.y;let edge1=triangle.b.xyz-triangle.a.xyz;let edge2=triangle.c.xyz-triangle.a.xyz;
+    let derivativeT=(edge1*du2.y-edge2*du1.y)/det;let derivativeB=(edge2*du1.x-edge1*du2.x)/det;tangent=normalize(derivativeT-normal*dot(derivativeT,normal))*sign;handedness=select(-1.0,1.0,dot(cross(normal,tangent),derivativeB)>=0.0);
+   }
+   let bitangent=normalize(cross(normal,tangent))*handedness*sign;normal=normalize(tangent*sampled.x+bitangent*sampled.y+normal*sampled.z);
+  }
+ }
+ var medium=material.physical;var specular=vec4f(select(material.attenuation.rgb,vec3f(1),medium.x>0.0),1.0-medium.w);
+ if(medium.x==0.0){specular*=vec4f(surfaceMap(material.attenuation.w-1.0,uv).rgb,surfaceMap(medium.z-1.0,uv).a);medium.z=0.0;}
+ var result=surfaceGraphApply(index,bary,front,view,SurfaceValue(color.rgb,color.a,normal,roughness,emissive,metalness,ao,0u,medium,specular));
+ let discarded=((!surfacePhysicalEnabled||material.physical.x==0.0)&&((material.maps1.w==0.0&&!front)||(material.maps1.w==1.0&&front)))||(material.factors.z>0.0&&result.alpha<=material.factors.z);
+ result.discarded=select(0u,1u,discarded);return result;
+}
+` + DEFAULT_SURFACE_GRAPHS;