pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/vertex-graphs.js

@@ -0,0 +1,197 @@
+import * as TSL from "three/tsl";
+import { sampleManagedTexture } from "./managed-texture-sampling.js";
+import { evaluateTypedGraph } from "./graph-expressions.js";
+import { typedGraphToTSL } from "./graph-tsl.js";
+const fail = (message) => {
+    throw new Error("TC_VERTEX_GRAPH: " +
+        message +
+        " Repair: Use finite vec3 vertex graphs, available attributes and declared texture/parameter bindings.");
+};
+const vec = (value, label) => {
+    if (!Array.isArray(value) ||
+        value.length !== 3 ||
+        value.some((component) => !Number.isFinite(Math.fround(component))))
+        return fail(label + " must produce a finite f32 vec3.");
+    return value.map(Math.fround);
+};
+const normalized = (value, fallback) => {
+    const scale = Math.max(...value.map(Math.abs));
+    if (!scale)
+        return [...fallback];
+    const scaled = value.map((component) => component / scale), length = Math.hypot(...scaled);
+    return scaled.map((component) => Math.fround(component / length));
+};
+export function evaluateVertexGraphs(binding, input, sampleTexture) {
+    if (!binding.vertex)
+        return { position: input.positionLocal };
+    const position = vec(input.positionLocal, "positionLocal");
+    const normal = normalized(vec(input.normalLocal, "normalLocal"), [0, 0, 0]);
+    const evaluate = (graph, channel) => {
+        try {
+            return vec(evaluateTypedGraph(graph, {
+                precision: "f32",
+                time: binding.time,
+                parameters: binding.parameters,
+                inputs: {
+                    positionLocal: position,
+                    normalLocal: normal,
+                    vertexIndex: input.vertexIndex,
+                    instanceIndex: input.instanceIndex,
+                    ...(input.uv ? { uv: input.uv } : {}),
+                    ...(input.uv1 ? { uv1: input.uv1 } : {}),
+                },
+                sampleTexture: (name, uv) => {
+                    const sampler = graph.textureSlots && Object.hasOwn(graph.textureSlots, name)
+                        ? graph.textureSlots[name]
+                        : undefined;
+                    if (!sampler)
+                        return sampleTexture(name, uv);
+                    const resource = binding.managedTextures &&
+                        Object.hasOwn(binding.managedTextures, name)
+                        ? binding.managedTextures[name]
+                        : undefined;
+                    if (!resource)
+                        throw new Error("TC_RENDER_TEXTURE_UNBOUND: " + binding.id + ":" + name);
+                    return sampleManagedTexture(resource, uv, sampler);
+                },
+                readBuffer: (name, index) => {
+                    const resource = binding.buffers?.[name];
+                    if (!resource)
+                        throw new Error("TC_RENDER_BUFFER_UNBOUND: " + binding.id + ":" + name);
+                    if (!Number.isSafeInteger(index) ||
+                        index < 0 ||
+                        index >= resource.values.length)
+                        throw new Error("TC_RENDER_BUFFER_BOUNDS: " +
+                            binding.id +
+                            ":" +
+                            name +
+                            ":" +
+                            index);
+                    return resource.values[index];
+                },
+            }), channel);
+        }
+        catch (error) {
+            return fail(binding.id +
+                ":" +
+                channel +
+                ":vertex=" +
+                input.vertexIndex +
+                ":instance=" +
+                input.instanceIndex +
+                ": " +
+                String(error));
+        }
+    };
+    const result = binding.vertex.position
+        ? evaluate(binding.vertex.position, "position")
+        : position;
+    return {
+        position: result,
+        ...(binding.vertex.normal
+            ? {
+                normal: normalized(evaluate(binding.vertex.normal, "normal"), normal),
+            }
+            : {}),
+    };
+}
+/** Engine-private bridge shared by surface capture and object bounds. */
+export function createVertexDeformer(bindings, sampler) {
+    const byUuid = new Map([...bindings].map(([material, binding]) => [material.uuid, binding]));
+    return {
+        evaluate(mesh, materialUuid, input) {
+            const binding = byUuid.get(materialUuid);
+            if (!binding?.vertex)
+                return undefined;
+            if (!mesh.geometry.hasAttribute("normal") &&
+                Object.values(binding.vertex).some((graph) => graph.requiredInputs?.includes("normalLocal")))
+                throw new Error("TC_VERTEX_NORMAL_ATTRIBUTE: The normalLocal vertex input requires a normal attribute.");
+            return evaluateVertexGraphs(binding, input, (asset, uv) => sampler(binding, asset, uv));
+        },
+        signature(mesh) {
+            const values = [];
+            for (const material of Array.isArray(mesh.material)
+                ? mesh.material
+                : [mesh.material]) {
+                const binding = byUuid.get(material.uuid);
+                if (!binding?.vertex)
+                    continue;
+                const graphs = Object.values(binding.vertex);
+                values.push(material.uuid, JSON.stringify(binding.vertex));
+                for (const name of [
+                    ...new Set(graphs.flatMap((graph) => Object.keys(graph.bufferTypes ?? {}))),
+                ].sort()) {
+                    const resource = binding.buffers?.[name] ??
+                        fail(binding.id + ": missing buffer " + name);
+                    values.push(name, resource.key, resource.type, resource.revision, resource.values.length);
+                }
+                if (graphs.some((graph) => graph.nodes.some((node) => node.op === "time")))
+                    values.push(Math.fround(binding.time));
+                const names = [
+                    ...new Set(graphs.flatMap((graph) => (graph.parameters ?? []).map((parameter) => parameter.name))),
+                ].sort();
+                for (const name of names)
+                    values.push(name, JSON.stringify(binding.parameters[name]));
+                const managedNames = new Set(graphs.flatMap((graph) => Object.keys(graph.textureSlots ?? {})));
+                for (const name of [...managedNames].sort()) {
+                    const resource = binding.managedTextures &&
+                        Object.hasOwn(binding.managedTextures, name)
+                        ? binding.managedTextures[name]
+                        : undefined;
+                    if (!resource?.texture || resource.type !== "vec4")
+                        return fail(binding.id + ": missing managed texture " + name);
+                    values.push(name, resource.key, resource.revision, resource.texture.width, resource.texture.height, resource.values.length);
+                    for (const graph of graphs) {
+                        const sampler = graph.textureSlots?.[name];
+                        if (sampler)
+                            values.push(sampler.filter ?? "linear", sampler.wrapU ?? "clamp", sampler.wrapV ?? "clamp");
+                    }
+                }
+                const textures = [
+                    ...new Set(graphs.flatMap((graph) => (graph.textureIds ?? []).filter((name) => !Object.hasOwn(graph.textureSlots ?? {}, name)))),
+                ].sort();
+                for (const asset of textures) {
+                    const texture = binding.textures.get(asset) ??
+                        fail(binding.id + ": missing texture " + asset);
+                    if (texture.matrixAutoUpdate)
+                        texture.updateMatrix();
+                    values.push(asset, texture.uuid, texture.version, texture.source.uuid, texture.source.version, texture.image, texture.flipY, texture.colorSpace, texture.wrapS, texture.wrapT, texture.magFilter, texture.minFilter, ...texture.matrix.elements);
+                }
+            }
+            return values;
+        },
+    };
+}
+/** Position node runs after Three's built-in morph/skin/instance stages. */
+export function vertexGraphsToTSL(binding, time, parameters, textures, readBuffer, sampleTextureSlot) {
+    if (!binding.vertex)
+        return null;
+    const safeNormal = (value, fallback) => {
+        const scale = TSL.max(TSL.max(TSL.abs(value.x), TSL.abs(value.y)), TSL.abs(value.z));
+        const scaled = value.div(TSL.select(scale.equal(0), 1, scale));
+        const length = scaled.length();
+        return TSL.select(length.equal(0), fallback, scaled.div(TSL.select(length.equal(0), 1, length)));
+    };
+    return TSL.Fn(() => {
+        const position = TSL.positionLocal.toVar();
+        const normal = safeNormal(TSL.normalLocal, TSL.vec3(0)).toVar();
+        const context = {
+            inputs: {
+                positionLocal: position,
+                normalLocal: normal,
+                vertexIndex: TSL.float(TSL.vertexIndex),
+                instanceIndex: TSL.float(TSL.instanceIndex),
+            },
+            readBuffer,
+            sampleTextureSlot,
+        };
+        const output = (binding.vertex.position
+            ? typedGraphToTSL(binding.vertex.position, time, parameters, textures, context)
+            : position).toVar();
+        if (binding.vertex.normal) {
+            const changed = typedGraphToTSL(binding.vertex.normal, time, parameters, textures, context);
+            TSL.normalLocal.assign(safeNormal(changed, normal));
+        }
+        return output;
+    })();
+}

package/lib/renderer/volume-shader.js

@@ -0,0 +1,50 @@
+/** Shared finite-roughness/delta dielectric mixture; medium state is owned by the path integrator. */
+export const VOLUME_SHADER = /* wgsl */ String.raw `
+struct TraceScatter{direction:vec3f,weight:vec3f,pdf:f32,eta:f32,event:u32,delta:u32,}
+struct TraceShadowMedia{incident:vec3f,transmitted:vec3f,}
+// Medium orientation comes from geometry, never a shading normal facing away from view.
+fn traceDielectric(surface:SurfaceValue)->DielectricMaterial{
+ return DielectricMaterial(surface.medium.y,surface.medium.z,surface.roughness,0u,clamp(surface.base,vec3f(0),vec3f(1)));
+}
+fn traceOpaqueIor(surface:SurfaceValue)->f32{return select(surface.medium.y,1.5,surface.medium.x>0.0);}
+fn traceEvaluate(surface:SurfaceValue,view:vec3f,light:vec3f)->vec3f{
+ if(dot(surface.normal,view)<=0.0){return vec3f(0);}
+ let opaque=bsdfEvaluateSpecular(surface.normal,view,light,clamp(surface.base,vec3f(0),vec3f(1)),surface.roughness,surface.metalness,traceOpaqueIor(surface),surface.specular.w,surface.specular.xyz);
+ if(!traceVolumeEnabled||surface.medium.x==0.0){return opaque;}let dielectric=dielectricEvaluate(surface.normal*surface.medium.w,view,light,traceDielectric(surface));return opaque*(1.0-surface.medium.x)+dielectric*surface.medium.x;
+}
+fn tracePdf(surface:SurfaceValue,view:vec3f,light:vec3f)->f32{
+ if(dot(surface.normal,view)<=0.0){return 0.0;}
+ let opaque=bsdfPdfSpecular(surface.normal,view,light,clamp(surface.base,vec3f(0),vec3f(1)),surface.roughness,surface.metalness,traceOpaqueIor(surface),surface.specular.w,surface.specular.xyz);
+ if(!traceVolumeEnabled||surface.medium.x==0.0){return opaque;}let dielectric=dielectricPdf(surface.normal*surface.medium.w,view,light,traceDielectric(surface));return opaque*(1.0-surface.medium.x)+dielectric*surface.medium.x;
+}
+fn traceScatter(surface:SurfaceValue,view:vec3f,branch:f32,random:vec3f)->TraceScatter{
+ if(dot(surface.normal,view)<=0.0){return TraceScatter(vec3f(0),vec3f(0),0,1,0u,0u);}
+ if(!traceVolumeEnabled||surface.medium.x==0.0){let sample=bsdfSampleSpecular(surface.normal,view,clamp(surface.base,vec3f(0),vec3f(1)),surface.roughness,surface.metalness,random,traceOpaqueIor(surface),surface.specular.w,surface.specular.xyz);return TraceScatter(sample.direction,sample.weight,sample.pdf,1,select(0u,1u,sample.pdf>0.0),0u);}
+ var direction:vec3f;var eta=1.0;var event=1u;
+ if(surface.medium.x>0.0&&branch<surface.medium.x){
+  let sample=dielectricSample(surface.normal*surface.medium.w,view,traceDielectric(surface),random);if(sample.event==0u){return TraceScatter(vec3f(0),vec3f(0),0,1,0u,0u);}
+  if(sample.delta!=0u){return TraceScatter(sample.direction,sample.weight,sample.pdf*surface.medium.x,sample.eta,sample.event,sample.delta);}
+  direction=sample.direction;eta=sample.eta;event=sample.event;
+ }else{let sample=bsdfSampleSpecular(surface.normal,view,clamp(surface.base,vec3f(0),vec3f(1)),surface.roughness,surface.metalness,random,traceOpaqueIor(surface),surface.specular.w,surface.specular.xyz);if(sample.pdf<=0.0){return TraceScatter(vec3f(0),vec3f(0),0,1,0u,0u);}direction=sample.direction;}
+ let pdf=tracePdf(surface,view,direction);if(pdf<=0.0){return TraceScatter(vec3f(0),vec3f(0),0,1,0u,0u);}let weight=traceEvaluate(surface,view,direction)*abs(dot(surface.normal,direction))/pdf;return TraceScatter(direction,weight,pdf,eta,event,0u);
+}
+fn traceValidDirection(geometric:vec3f,surface:SurfaceValue,direction:vec3f)->bool{
+ let gn=dot(geometric,direction);let sn=dot(surface.normal,direction);return select(gn>0.0&&sn>0.0,gn*sn>0.0,traceVolumeEnabled&&surface.medium.x>0.0);
+}
+fn traceCosine(surface:SurfaceValue,direction:vec3f)->f32{return select(max(dot(surface.normal,direction),0.0),abs(dot(surface.normal,direction)),traceVolumeEnabled&&surface.medium.x>0.0);}
+struct TracePoint{position:vec3f,error:vec3f,}
+fn tracePoint(triangle:SurfaceTriangle,bary:vec3f)->TracePoint{
+ let a=triangle.a.xyz*bary.x;let b=triangle.b.xyz*bary.y;let c=triangle.c.xyz*bary.z;
+ return TracePoint(a+b+c,(abs(a)+abs(b)+abs(c))*4.172327e-7);
+}
+fn traceOffset(point:TracePoint,geometric:vec3f,direction:vec3f)->vec3f{
+ let offset=geometric*(dot(abs(geometric),point.error)*select(-1.0,1.0,dot(geometric,direction)>0.0));
+ var result=point.position+offset;
+ for(var axis=0u;axis<3u;axis++){
+  if(offset[axis]==0.0){continue;}
+  if(result[axis]==0.0){result[axis]=select(-1.17549435e-38,1.17549435e-38,offset[axis]>0.0);}
+  else{let step=select(-1,1,(result[axis]>0.0)==(offset[axis]>0.0));result[axis]=bitcast<f32>(bitcast<i32>(result[axis])+step);}
+ }
+ return result;
+}
+`;

package/lib/runtime/compute-contract.js

@@ -0,0 +1 @@
+export {};