@babylonjs/lite 0.1.1

package/index.js

@@ -0,0 +1,309 @@
+import { bI, bJ, bK, bL, M, bM, bN, bO, bP, bQ, bR, bS, bT, bU, bV, bW, bX, bY, bZ, b_, b$, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf, cg, ch, ci, cj, ck, cl, cm, cn, co, cp, cq, cr, cs, ct, cu, cv, cw, cx, cy, cz, cA, cB, cC, cD, cE, cF, cG, cH, cI, cJ, cK, cL, cM, cN, cO, cP, cQ, cR, cS, cT, cU, cV, C, cW, cX, cY, cZ, c_, c$, d0, bq, d1, Q, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df, dg, dh, di, dj, dk, dl, dm, dn, dp, dq, dr, ds, dt, du, dv, dw, dx, dy, dz, dA, dB, dC, dD, dE, dF, dG, dH, dI, dJ, dK, dL, dM, dN, dO, dP, dQ, dR, dS, dT, dU, dV, dW, dX, dY, dZ, d_, d$, e0, e1, e2, e3, e4, e5, e6, e7, e8, W, e9, ea, eb, ec, ed, ee, ef, eg, O, eh, a$, ei, ej, ek, el, em, en, eo, L, ep, eq, K, b0, er, es, Y, et, eu, ev, ew, ex, ey, ez, eA, eB, eC, eD, eE, eF, eG, eH, eI, eJ, m, eK, k, eL, eM, eN, eO, eP, eQ, eR, eS, eT, eU, eV, eW, eX, eY, eZ, e_, e$, f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff, fg, fh, fi, fj, fk, fl, fm, fn, fo, fp, fq, fr, fs, ft, s, h, fu, fv, fw, fx, fy, fz, fA, fB, fC, fD, fE, fF, fG, fH, fI, fJ, fK, fL, fM, h as h2, fN, fO, v, fP, fQ, fR, fS, fT, fU, fV, fW, fX, fY, fZ, f_, f$, g0, g1, g2, g3, g4, g5, g6, g7, g8, g9, ga, gb, gc } from "./index-C8HOR2sB.js";
+export {
+  bI as CAP_ALL,
+  bJ as CAP_END,
+  bK as CAP_NONE,
+  bL as CAP_START,
+  M as MAX_LIGHTS,
+  bM as ObservableQuat,
+  bN as ObservableVec3,
+  bO as PhysicsMotionType,
+  bP as PhysicsShapeType,
+  bQ as VERSION,
+  bR as addAgent,
+  bS as addAnimationGroup,
+  bT as addAnimationGroups,
+  bU as addAnimationTask,
+  bV as addAxisLockedBillboardSystem,
+  bW as addBillboardSprite,
+  bX as addBillboardSpriteIndex,
+  bY as addBoxObstacle,
+  bZ as addCylinderObstacle,
+  b_ as addDepthHostedSpriteLayer,
+  b$ as addFacingBillboardSystem,
+  c0 as addPassDependencies,
+  c1 as addRenderPass,
+  c2 as addSprite2D,
+  c3 as addSprite2DIndex,
+  c4 as addSpriteAnimation,
+  c5 as addSpriteAnimationManager,
+  c6 as addSpriteRendererLayer,
+  c7 as addTask,
+  c8 as addTaskAtStart,
+  c9 as addTaskBefore,
+  ca as addThinInstance,
+  cb as addToScene,
+  cc as agentGoto,
+  cd as attachControl,
+  ce as attachFreeControl,
+  cf as attachSpriteAnimationsToRenderer,
+  cg as attachSpriteAnimationsToScene,
+  ch as bakeCurrentTransformIntoVertices,
+  ci as bakeTransformIntoVertices,
+  cj as billboardBlendAdditive,
+  ck as billboardBlendAlpha,
+  cl as billboardBlendCutout,
+  cm as billboardBlendPremultiplied,
+  cn as clearAnimationManager,
+  co as clearBillboardSprites,
+  cp as clearSprite2DLayer,
+  cq as clearSpriteAnimations,
+  cr as cloneTransformNode,
+  cs as computePath,
+  ct as createAnaglyphPostProcessTask,
+  cu as createAnimationController,
+  cv as createAnimationGroups,
+  cw as createAnimationManager,
+  cx as createAnimationTask,
+  cy as createArcRotateCamera,
+  cz as createAxisLockedBillboardSystem,
+  cA as createBillboardCustomShader,
+  cB as createBlackAndWhitePostProcessTask,
+  cC as createBloomPostProcessTask,
+  cD as createBlurPostProcessTask,
+  cE as createBox,
+  cF as createChromaticAberrationPostProcessTask,
+  cG as createCsg2FromMesh,
+  cH as createCsgFromMesh,
+  cI as createCylinder,
+  cJ as createDebugNavMeshGeometry,
+  cK as createDefaultCamera,
+  cL as createDirectionalLight,
+  cM as createDisc,
+  cN as createEffectRenderTask,
+  cO as createEffectRenderer,
+  cP as createEffectWrapper,
+  cQ as createEngine,
+  cR as createEsmDirectionalShadowGenerator,
+  cS as createExtractHighlightsPostProcessTask,
+  cT as createExtrudeShape,
+  cU as createFacingBillboardSystem,
+  cV as createFrameGraphContext,
+  C as createFreeCamera,
+  cW as createGpuPicker,
+  cX as createGridMaterial,
+  cY as createGridSpriteAtlas,
+  cZ as createGround,
+  c_ as createGroundFromHeightMap,
+  c$ as createHavokWorld,
+  d0 as createHemisphericLight,
+  bq as createImageProcessingTask,
+  d1 as createLinearDepthMaterial,
+  Q as createMaterialView,
+  d2 as createMeshFromCsg,
+  d3 as createMeshFromCsg2,
+  d4 as createMeshFromData,
+  d5 as createMeshesFromCsg2,
+  d6 as createMorphTargets,
+  d7 as createNavCrowd,
+  d8 as createNavMesh,
+  d9 as createNavigationPluginAsync,
+  da as createNodeNoColorMaterialView,
+  db as createPbrMaterial,
+  dc as createPbrNoColorMaterialView,
+  dd as createPcfDirectionalShadowGenerator,
+  de as createPcfSpotlightShadowGenerator,
+  df as createPhysicsAggregate,
+  dg as createPhysicsBody,
+  dh as createPhysicsShape,
+  di as createPlane,
+  dj as createPointLight,
+  dk as createPolyhedron,
+  dl as createProceduralGaussianSplattingMesh,
+  dm as createPropertyAnimationClip,
+  dn as createPropertyAnimationGroup,
+  dp as createRenderTarget,
+  dq as createRenderTargetTexture,
+  dr as createRenderTask,
+  ds as createRibbon,
+  dt as createSceneContext,
+  du as createShaderMaterial,
+  dv as createShadowTask,
+  dw as createSolidTexture2D,
+  dx as createSphere,
+  dy as createSphereData,
+  dz as createSpotLight,
+  dA as createSprite2DCustomShader,
+  dB as createSprite2DLayer,
+  dC as createSpriteAnimationManager,
+  dD as createSpriteAtlasFromFrames,
+  dE as createSpriteFrameAnimation,
+  dF as createSpriteRenderer,
+  dG as createStandardMaterial,
+  dH as createStandardNoColorMaterialView,
+  dI as createTexture2DFromPixels,
+  dJ as createTorus,
+  dK as createTransformNode,
+  dL as createTube,
+  dM as createUniformEffectRenderTask,
+  dN as createUniformEffectWrapper,
+  dO as crossFadeAnimationGroups,
+  dP as csg2Add,
+  dQ as csg2Intersect,
+  dR as csg2Subtract,
+  dS as csgIntersect,
+  dT as csgSubtract,
+  dU as csgUnion,
+  dV as disposeCsg2,
+  dW as disposeEffectRenderer,
+  dX as disposeEffectWrapper,
+  dY as disposeEngine,
+  dZ as disposeFrameGraphContext,
+  d_ as disposePhysics,
+  d$ as disposePicker,
+  e0 as disposeScene,
+  e1 as disposeSpriteAnimationBinding,
+  e2 as disposeSpriteRenderer,
+  e3 as disposeUniformEffectWrapper,
+  e4 as enableAnimationBlending,
+  e5 as enableDetailedPicking,
+  e6 as enableMaterialTracking,
+  e7 as enablePropertyAnimationBlending,
+  e8 as enableThinInstanceGpuCulling,
+  W as encodeIdToColor,
+  e9 as fadeAnimationWeight,
+  ea as findRandomPoint,
+  eb as findRandomPointAroundCircle,
+  ec as flushThinInstances,
+  ed as getAgentPosition,
+  ee as getAgentVelocity,
+  ef as getAnimationGroups,
+  eg as getBillboardSpriteHandleIndex,
+  O as getCameraPosition,
+  eh as getClosestPoint,
+  a$ as getEffectiveAspectRatio,
+  ei as getFrameGraph,
+  ej as getNavigationRandomSeed,
+  ek as getPhysicsGravity,
+  el as getPhysicsTimestep,
+  em as getPhysicsVelocityLimits,
+  en as getPickedNormal,
+  eo as getPickedUV,
+  L as getProjectionMatrix,
+  ep as getSprite2DHandleIndex,
+  eq as getVariantNames,
+  K as getViewMatrix,
+  b0 as getViewProjectionMatrix,
+  er as goToFrame,
+  es as gsAlphaBlendedDepthFragment,
+  Y as gsGpuPickingFragment,
+  et as gsLinearDepthFragment,
+  eu as initializeCsg2Async,
+  ev as isBillboardSpriteHandleAlive,
+  ew as isCsg2Ready,
+  ex as isSprite2DHandleAlive,
+  ey as loadBabylon,
+  ez as loadBasisTexture2D,
+  eA as loadEnvironment,
+  eB as loadGltf,
+  eC as loadHdrEnvironment,
+  eD as loadKtxTexture2D,
+  eE as loadSOG,
+  eF as loadSPZ,
+  eG as loadSkybox,
+  eH as loadSplat,
+  eI as loadSpriteAtlas,
+  eJ as loadTexture2D,
+  m as markMaterialUboDirty,
+  eK as mat4Compose,
+  k as mat4Identity,
+  eL as mat4Scale,
+  eM as mat4Translation,
+  eN as normalizeVec3,
+  eO as onBeforeRender,
+  eP as onSceneDispose,
+  eQ as parseNodeMaterialFromSnippet,
+  eR as pauseAnimation,
+  eS as pickAsync,
+  eT as playAnimation,
+  eU as playBillboardSpriteAnimation,
+  eV as playBillboardSpriteIndexAnimation,
+  eW as playSprite2DAnimation,
+  eX as playSprite2DIndexAnimation,
+  eY as playSpriteFrameAnimation,
+  eZ as raycast,
+  e_ as rebuildMaterial,
+  e$ as registerEffectRenderer,
+  f0 as registerFrameGraphContext,
+  f1 as registerScene,
+  f2 as registerSceneWithShadowSupport,
+  f3 as registerSpriteRenderer,
+  f4 as removeAnimationGroup,
+  f5 as removeAnimationTask,
+  f6 as removeBillboardSprite,
+  f7 as removeBillboardSpriteIndex,
+  f8 as removeFromScene,
+  f9 as removeMeshFromTask,
+  fa as removeObstacle,
+  fb as removeSprite2D,
+  fc as removeSprite2DIndex,
+  fd as removeSpriteAnimation,
+  fe as removeSpriteAnimationManager,
+  ff as removeSpriteRendererLayer,
+  fg as removeThinInstance,
+  fh as resetVariant,
+  fi as resizeEngine,
+  fj as resolveCameraViewport,
+  fk as selectVariant,
+  fl as setAnimationAdditive,
+  fm as setAnimationTaskCategoryHandler,
+  fn as setAnimationWeight,
+  fo as setBillboardShaderParams,
+  fp as setBillboardSpriteFrame,
+  fq as setBillboardSpriteFrameIndex,
+  fr as setEffectTexture,
+  fs as setEffectUniforms,
+  ft as setEngineSize,
+  s as setMaxLights,
+  h as setMeshVisible,
+  fu as setMorphTargetWeights,
+  fv as setNavigationRandomSeed,
+  fw as setParent,
+  fx as setPhysicsBodyMass,
+  fy as setPhysicsBodyShape,
+  fz as setPhysicsGravity,
+  fA as setPhysicsShapeMaterial,
+  fB as setPhysicsTimestep,
+  fC as setPhysicsVelocityLimits,
+  fD as setShaderFloat,
+  fE as setShaderMatrix,
+  fF as setShaderTexture,
+  fG as setShaderUniform,
+  fH as setShaderVector3,
+  fI as setShadowTaskCasterMeshes,
+  fJ as setSprite2DFrame,
+  fK as setSprite2DFrameIndex,
+  fL as setSprite2DShaderParams,
+  fM as setSprite2DUvOffset,
+  h2 as setSubtreeVisible,
+  fN as setThinInstanceColors,
+  fO as setThinInstanceMatrix,
+  v as setThinInstances,
+  fP as setUniformEffectUniforms,
+  fQ as spriteBlendAdditive,
+  fR as spriteBlendAlpha,
+  fS as spriteBlendMultiply,
+  fT as spriteBlendPremultiplied,
+  fU as startAnimationManager,
+  fV as startEngine,
+  fW as startSpriteAnimationManager,
+  fX as stopAnimation,
+  fY as stopAnimationManager,
+  fZ as stopEngine,
+  f_ as stopSpriteAnimation,
+  f$ as stopSpriteAnimationManager,
+  g0 as unregisterEffectRenderer,
+  g1 as unregisterFrameGraphContext,
+  g2 as unregisterScene,
+  g3 as unregisterSpriteRenderer,
+  g4 as updateAnimationManager,
+  g5 as updateBillboardSprite,
+  g6 as updateBillboardSpriteIndex,
+  g7 as updateMeshPositions,
+  g8 as updateNavCrowd,
+  g9 as updateNavMeshObstacles,
+  ga as updateSprite2D,
+  gb as updateSprite2DIndex,
+  gc as updateSpriteAnimationManager
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/input-block-DgAJBzN_.js

@@ -0,0 +1,109 @@
+import { aS as WGSL } from "./index-C8HOR2sB.js";
+function bjsTypeToNodeType(t) {
+  if (t === 1 || t === 2) {
+    return "f32";
+  }
+  if (t === 4) {
+    return "vec2f";
+  }
+  if (t === 8 || t === 32) {
+    return "vec3f";
+  }
+  if (t === 16 || t === 64) {
+    return "vec4f";
+  }
+  if (t === 128) {
+    return "mat4f";
+  }
+  throw new Error(`InputBlock: unsupported BJS connection point type 0x${t.toString(16)}`);
+}
+const ATTRIBUTE_TYPES = {
+  position: "vec3f",
+  normal: "vec3f",
+  tangent: "vec4f",
+  uv: "vec2f",
+  uv2: "vec2f",
+  color: "vec4f",
+  matricesIndices: "vec4f",
+  matricesWeights: "vec4f",
+  matricesIndicesExtra: "vec4f",
+  matricesWeightsExtra: "vec4f"
+};
+function emitAttribute(block, stage, state) {
+  const attrName = block.name;
+  const type = ATTRIBUTE_TYPES[attrName];
+  if (!type) {
+    throw new Error(`InputBlock: unknown mesh attribute "${attrName}"`);
+  }
+  const wgslType = WGSL[type];
+  if (!state.vertexAttributes.find((a) => a._name === attrName)) {
+    state.vertexAttributes.push({
+      _name: attrName,
+      _type: wgslType,
+      _gpuFormat: type === "vec2f" ? "float32x2" : type === "vec3f" ? "float32x3" : "float32x4",
+      _arrayStride: (type === "vec2f" ? 2 : type === "vec3f" ? 3 : 4) * 4
+    });
+  }
+  if (stage === "vertex") {
+    return { expr: `in.${attrName}`, type };
+  }
+  const vname = `v_attr_${attrName}`;
+  if (!state.varyings.find((v) => v._name === vname)) {
+    state.varyings.push({ _name: vname, _type: wgslType });
+    state.vertex.body.push(`out.${vname} = in.${attrName};`);
+  }
+  return { expr: `in.${vname}`, type };
+}
+function emitSystemValue(block, stage, state) {
+  const sv = block.serialized["systemValue"];
+  switch (sv) {
+    case 1:
+      return { expr: "meshU.world", type: "mat4f" };
+    case 2:
+      return { expr: "sceneU.view", type: "mat4f" };
+    case 3:
+      return { expr: "sceneU.projection", type: "mat4f" };
+    case 4:
+      return { expr: "sceneU.viewProjection", type: "mat4f" };
+    case 5:
+      return { expr: "(sceneU.view * meshU.world)", type: "mat4f" };
+    case 6:
+      return { expr: "(sceneU.viewProjection * meshU.world)", type: "mat4f" };
+    case 7:
+      return { expr: "sceneU.vEyePosition.xyz", type: "vec3f" };
+    case 8:
+      return { expr: "sceneU.vFogColor.xyz", type: "vec3f" };
+    default:
+      throw new Error(`InputBlock: unsupported systemValue ${sv} on block "${block.name}"`);
+  }
+}
+function emitUniform(block, state) {
+  const portType = block.serialized["type"] ?? 16;
+  const type = bjsTypeToNodeType(portType);
+  const fieldName = sanitize(block.name || `input${block.id}`);
+  if (!state.nodeUboFields.find((f) => f._name === fieldName)) {
+    state.nodeUboFields.push({ _name: fieldName, _type: WGSL[type] });
+  }
+  return { expr: `nodeU.${fieldName}`, type };
+}
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+const emitter = {
+  className: "InputBlock",
+  emit(block, _outputName, stage, state, _ctx) {
+    const mode = block.serialized["mode"] ?? block.serialized["_mode"];
+    if (mode === 1) {
+      return emitAttribute(block, stage, state);
+    }
+    const sv = block.serialized["systemValue"];
+    if (typeof sv === "number") {
+      return emitSystemValue(block);
+    }
+    return emitUniform(block, state);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=input-block-DgAJBzN_.js.map

package/input-block-DgAJBzN_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-block-DgAJBzN_.js","sources":["../src/material/node/blocks/input-block.ts"],"sourcesContent":["/** InputBlock emitter.\n *\n *  Three modes (BJS NodeMaterialBlockConnectionPointMode):\n *    0 = Uniform   — inline value becomes a field in the node UBO.\n *    1 = Attribute — bound to a vertex attribute (position/normal/uv/...).\n *    2 = Varying   — interpolated from a system/pre-existing varying.\n *\n *  For attributes we declare the vertex attribute (dedup by name) and, if the\n *  value is consumed in fragment stage, a varying to carry it across.\n */\n\nimport type { BlockEmitter, NodeBuildState, NodeExpr, NodeValueType, Stage, NodeBlock } from \"../node-types.js\";\nimport { WGSL } from \"../node-types.js\";\n\ntype BjsType = number; // NodeMaterialBlockConnectionPointTypes\n\nfunction bjsTypeToNodeType(t: BjsType): NodeValueType {\n    // bitflags: 0x1=Float, 0x4=Vec2, 0x8=Vec3, 0x10=Vec4, 0x20=Color3, 0x40=Color4\n    if (t === 0x1 || t === 0x2) {\n        return \"f32\";\n    }\n    if (t === 0x4) {\n        return \"vec2f\";\n    }\n    if (t === 0x8 || t === 0x20) {\n        return \"vec3f\";\n    }\n    if (t === 0x10 || t === 0x40) {\n        return \"vec4f\";\n    }\n    if (t === 0x80) {\n        return \"mat4f\";\n    }\n    throw new Error(`InputBlock: unsupported BJS connection point type 0x${t.toString(16)}`);\n}\n\nfunction wgslLiteral(value: unknown, type: NodeValueType): string {\n    if (type === \"f32\") {\n        const f = typeof value === \"number\" ? value : 0;\n        return formatFloat(f);\n    }\n    if (Array.isArray(value)) {\n        const parts = value.map((v) => formatFloat(typeof v === \"number\" ? v : 0)).join(\", \");\n        return `${WGSL[type]}(${parts})`;\n    }\n    // Fallback to zero.\n    if (type === \"vec2f\") {\n        return \"vec2<f32>(0.0, 0.0)\";\n    }\n    if (type === \"vec3f\") {\n        return \"vec3<f32>(0.0, 0.0, 0.0)\";\n    }\n    if (type === \"vec4f\") {\n        return \"vec4<f32>(0.0, 0.0, 0.0, 0.0)\";\n    }\n    return \"0.0\";\n}\n\nfunction formatFloat(n: number): string {\n    if (Number.isInteger(n)) {\n        return `${n}.0`;\n    }\n    return `${n}`;\n}\n\n// Known mesh attributes — maps InputBlock.name → WGSL type.\nconst ATTRIBUTE_TYPES: Record<string, NodeValueType> = {\n    position: \"vec3f\",\n    normal: \"vec3f\",\n    tangent: \"vec4f\",\n    uv: \"vec2f\",\n    uv2: \"vec2f\",\n    color: \"vec4f\",\n    matricesIndices: \"vec4f\",\n    matricesWeights: \"vec4f\",\n    matricesIndicesExtra: \"vec4f\",\n    matricesWeightsExtra: \"vec4f\",\n};\n\nfunction emitAttribute(block: NodeBlock, stage: Stage, state: NodeBuildState): NodeExpr {\n    const attrName = block.name;\n    const type = ATTRIBUTE_TYPES[attrName];\n    if (!type) {\n        throw new Error(`InputBlock: unknown mesh attribute \"${attrName}\"`);\n    }\n    const wgslType = WGSL[type];\n    // Dedup vertex attribute.\n    if (!state.vertexAttributes.find((a) => a._name === attrName)) {\n        state.vertexAttributes.push({\n            _name: attrName,\n            _type: wgslType,\n            _gpuFormat: type === \"vec2f\" ? \"float32x2\" : type === \"vec3f\" ? \"float32x3\" : \"float32x4\",\n            _arrayStride: (type === \"vec2f\" ? 2 : type === \"vec3f\" ? 3 : 4) * 4,\n        });\n    }\n    if (stage === \"vertex\") {\n        return { expr: `in.${attrName}`, type };\n    }\n    // In fragment stage — bridge through a varying (idempotent).\n    const vname = `v_attr_${attrName}`;\n    if (!state.varyings.find((v) => v._name === vname)) {\n        state.varyings.push({ _name: vname, _type: wgslType });\n        state.vertex.body.push(`out.${vname} = in.${attrName};`);\n    }\n    return { expr: `in.${vname}`, type };\n}\n\n// BJS NodeMaterialSystemValues enum (Babylon.js master).\n// We map the commonly used ones to WGSL expressions sourced from scene/mesh UBOs.\n// For matrices not present in Lite's scene UBO (`projection` alone), we fall\n// back to the closest valid expression (or throw — caller decides).\nfunction emitSystemValue(block: NodeBlock, stage: Stage, state: NodeBuildState): NodeExpr {\n    const sv = block.serialized[\"systemValue\"] as number | undefined;\n    // Only sensible in the vertex stage for matrix types; for CameraPosition/FogColor either stage is fine.\n    switch (sv) {\n        case 1: // World\n            return { expr: \"meshU.world\", type: \"mat4f\" };\n        case 2: // View\n            return { expr: \"sceneU.view\", type: \"mat4f\" };\n        case 3: // Projection\n            return { expr: \"sceneU.projection\", type: \"mat4f\" };\n        case 4: // ViewProjection\n            return { expr: \"sceneU.viewProjection\", type: \"mat4f\" };\n        case 5: // WorldView\n            return { expr: \"(sceneU.view * meshU.world)\", type: \"mat4f\" };\n        case 6: // WorldViewProjection\n            return { expr: \"(sceneU.viewProjection * meshU.world)\", type: \"mat4f\" };\n        case 7: // CameraPosition\n            return { expr: \"sceneU.vEyePosition.xyz\", type: \"vec3f\" };\n        case 8: // FogColor\n            return { expr: \"sceneU.vFogColor.xyz\", type: \"vec3f\" };\n        default:\n            throw new Error(`InputBlock: unsupported systemValue ${sv} on block \"${block.name}\"`);\n    }\n    void stage;\n    void state;\n}\n\nfunction emitUniform(block: NodeBlock, state: NodeBuildState): NodeExpr {\n    // Determine the WGSL type. BJS serializes the port type under `type`.\n    const portType = (block.serialized[\"type\"] as BjsType | undefined) ?? 0x10;\n    const type = bjsTypeToNodeType(portType);\n    // UBO field name — use block name (must be unique; parser enforces via namedInputs key).\n    const fieldName = sanitize(block.name || `input${block.id}`);\n    // Dedup.\n    if (!state.nodeUboFields.find((f) => f._name === fieldName)) {\n        state.nodeUboFields.push({ _name: fieldName, _type: WGSL[type] as any });\n        // If this is a literal value (no override yet), it will be written into the\n        // UBO at material-build time; for shader generation we just reference the field.\n        // We ignore the inline literal here — the UBO write path handles that.\n    }\n    void wgslLiteral; // reserved for future default-literal constant-fold optimization\n    return { expr: `nodeU.${fieldName}`, type };\n}\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"InputBlock\",\n    emit(block, _outputName, stage, state, _ctx) {\n        const mode = (block.serialized[\"mode\"] ?? block.serialized[\"_mode\"]) as number | undefined;\n        if (mode === 1) {\n            return emitAttribute(block, stage, state);\n        }\n        // System-value uniforms (World, WVP, CameraPosition, …) come from scene/mesh UBOs\n        // rather than the material's node UBO, so they never appear in `nodeUboFields`.\n        const sv = block.serialized[\"systemValue\"];\n        if (typeof sv === \"number\") {\n            return emitSystemValue(block, stage, state);\n        }\n        // Default to Uniform (mode 0 or unspecified).\n        return emitUniform(block, state);\n    },\n};\n"],"names":[],"mappings":"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"}

package/instances-block-BaSSiz8m.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "InstancesBlock",
+  stage: "vertex",
+  emit(_block, _outputName, _stage, state, _ctx) {
+    if (state.hasInstances) ;
+    return { expr: "meshU.world", type: "mat4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=instances-block-BaSSiz8m.js.map

package/instances-block-BaSSiz8m.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances-block-BaSSiz8m.js","sources":["../src/material/node/blocks/instances-block.ts"],"sourcesContent":["/** InstancesBlock — picks between per-instance and uniform world matrix.\n *\n *  When instancing is enabled the pipeline builder wires `in.world0..world3`\n *  (4x vec4 attribute) and the block's output becomes the reconstructed mat4x4.\n *  Otherwise the output is the scene-provided uniform `_NME_WORLD_MATRIX_`.\n *\n *  The choice is made at pipeline-build time by reading serialized flag\n *  `isThinInstance` or by inspecting mesh metadata; for graph-walk purposes we\n *  always emit the sentinel, and the pipeline builder rewrites it.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"InstancesBlock\",\n    stage: \"vertex\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        if (state.hasInstances) {\n            // TODO: wire per-instance world attributes. For now passthrough.\n        }\n        return { expr: \"meshU.world\", type: \"mat4f\" };\n    },\n};\n"],"names":[],"mappings":"AAaO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,QAAI,MAAM,aAAc;AAGxB,WAAO,EAAE,MAAM,eAAe,MAAM,QAAA;AAAA,EACxC;AACJ;"}

package/iridescence-block-B0pRFoOU.js

@@ -0,0 +1,67 @@
+const IRIDESCENCE_HELPERS = `const NME_PBR_XYZ_TO_REC709: mat3x3<f32> = mat3x3<f32>(
+    3.2404542, -0.9692660, 0.0556434,
+    -1.5371385, 1.8760108, -0.2040259,
+    -0.4985314, 0.0415560, 1.0572252
+);
+fn nme_pbr_square3(x: vec3<f32>) -> vec3<f32> { return x * x; }
+fn nme_pbr_iorFromAirF0(f0: vec3<f32>) -> vec3<f32> {
+    let s = sqrt(clamp(f0, vec3<f32>(0.0), vec3<f32>(0.9999)));
+    return (vec3<f32>(1.0) + s) / (vec3<f32>(1.0) - s);
+}
+fn nme_pbr_r0FromIor3(iorT: vec3<f32>, iorI: f32) -> vec3<f32> { return nme_pbr_square3((iorT - vec3<f32>(iorI)) / (iorT + vec3<f32>(iorI))); }
+fn nme_pbr_r0FromIor(iorT: f32, iorI: f32) -> f32 { let r = (iorT - iorI) / (iorT + iorI); return r * r; }
+fn nme_pbr_evalSensitivity(opd: f32, shift: vec3<f32>) -> vec3<f32> {
+    let phase = 6.283185307179586 * opd * 1.0e-9;
+    let val = vec3<f32>(5.4856e-13, 4.4201e-13, 5.2481e-13);
+    let pos = vec3<f32>(1.6810e+06, 1.7953e+06, 2.2084e+06);
+    let vr = vec3<f32>(4.3278e+09, 9.3046e+09, 6.6121e+09);
+    var xyz = val * sqrt(6.283185307179586 * vr) * cos(pos * phase + shift) * exp(-(phase * phase) * vr);
+    xyz.x = xyz.x + 9.7470e-14 * sqrt(6.283185307179586 * 4.5282e+09) * cos(2.2399e+06 * phase + shift.x) * exp(-4.5282e+09 * phase * phase);
+    xyz = xyz / 1.0685e-7;
+    return NME_PBR_XYZ_TO_REC709 * xyz;
+}
+fn nme_pbr_evalIridescence(outsideIor: f32, eta2: f32, cosTheta1: f32, thickness: f32, baseF0: vec3<f32>) -> vec3<f32> {
+    let iridescenceIor = mix(outsideIor, eta2, smoothstep(0.0, 0.03, thickness));
+    let sinTheta2Sq = ((outsideIor / iridescenceIor) * (outsideIor / iridescenceIor)) * (1.0 - cosTheta1 * cosTheta1);
+    let cosTheta2Sq = 1.0 - sinTheta2Sq;
+    if (cosTheta2Sq < 0.0) { return vec3<f32>(1.0); }
+    let cosTheta2 = sqrt(cosTheta2Sq);
+    let r0 = nme_pbr_r0FromIor(iridescenceIor, outsideIor);
+    let r12 = nme_pbr_fresSchlick(cosTheta1, vec3<f32>(r0), vec3<f32>(1.0)).x;
+    let t121 = 1.0 - r12;
+    var phi12 = 0.0;
+    if (iridescenceIor < outsideIor) { phi12 = 3.141592653589793; }
+    let phi21 = 3.141592653589793 - phi12;
+    let baseIor = nme_pbr_iorFromAirF0(baseF0);
+    let r1 = nme_pbr_r0FromIor3(baseIor, iridescenceIor);
+    let r23 = nme_pbr_fresSchlick(cosTheta2, r1, vec3<f32>(1.0));
+    var phi23 = vec3<f32>(0.0);
+    if (baseIor.x < iridescenceIor) { phi23.x = 3.141592653589793; }
+    if (baseIor.y < iridescenceIor) { phi23.y = 3.141592653589793; }
+    if (baseIor.z < iridescenceIor) { phi23.z = 3.141592653589793; }
+    let opd = 2.0 * iridescenceIor * thickness * cosTheta2;
+    let phi = vec3<f32>(phi21) + phi23;
+    let r123 = clamp(vec3<f32>(r12) * r23, vec3<f32>(1e-5), vec3<f32>(0.9999));
+    let smallR123 = sqrt(r123);
+    let rs = (t121 * t121) * r23 / (vec3<f32>(1.0) - r123);
+    var outI = vec3<f32>(r12) + rs;
+    var cm = rs - vec3<f32>(t121);
+    for (var m: i32 = 1; m <= 2; m = m + 1) {
+        cm = cm * smallR123;
+        outI = outI + cm * (2.0 * nme_pbr_evalSensitivity(f32(m) * opd, f32(m) * phi));
+    }
+    return max(outI, vec3<f32>(0.0));
+}`;
+const emitter = {
+  className: "IridescenceBlock",
+  stage: "fragment",
+  emit(_block, _outputName, _stage, state, _ctx) {
+    state.usesIridescence = true;
+    state.fragment.helpers.set("nme_pbr_iridescence_helpers", IRIDESCENCE_HELPERS);
+    return { expr: `vec3<f32>(0.0)`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=iridescence-block-B0pRFoOU.js.map

package/iridescence-block-B0pRFoOU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iridescence-block-B0pRFoOU.js","sources":["../src/material/node/blocks/iridescence-block.ts"],"sourcesContent":["/** IridescenceBlock — marker for PBR-MR thin-film Fresnel.\n *\n *  The block itself returns an object output in Babylon.js. Lite keeps object\n *  sockets as marker blocks: PBRMetallicRoughnessBlock walks into the connected\n *  IridescenceBlock and reads `intensity`, `indexOfRefraction`, and `thickness`\n *  so only graphs that use iridescence pay for the thin-film helper code.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nconst IRIDESCENCE_HELPERS = `const NME_PBR_XYZ_TO_REC709: mat3x3<f32> = mat3x3<f32>(\n    3.2404542, -0.9692660, 0.0556434,\n    -1.5371385, 1.8760108, -0.2040259,\n    -0.4985314, 0.0415560, 1.0572252\n);\nfn nme_pbr_square3(x: vec3<f32>) -> vec3<f32> { return x * x; }\nfn nme_pbr_iorFromAirF0(f0: vec3<f32>) -> vec3<f32> {\n    let s = sqrt(clamp(f0, vec3<f32>(0.0), vec3<f32>(0.9999)));\n    return (vec3<f32>(1.0) + s) / (vec3<f32>(1.0) - s);\n}\nfn nme_pbr_r0FromIor3(iorT: vec3<f32>, iorI: f32) -> vec3<f32> { return nme_pbr_square3((iorT - vec3<f32>(iorI)) / (iorT + vec3<f32>(iorI))); }\nfn nme_pbr_r0FromIor(iorT: f32, iorI: f32) -> f32 { let r = (iorT - iorI) / (iorT + iorI); return r * r; }\nfn nme_pbr_evalSensitivity(opd: f32, shift: vec3<f32>) -> vec3<f32> {\n    let phase = 6.283185307179586 * opd * 1.0e-9;\n    let val = vec3<f32>(5.4856e-13, 4.4201e-13, 5.2481e-13);\n    let pos = vec3<f32>(1.6810e+06, 1.7953e+06, 2.2084e+06);\n    let vr = vec3<f32>(4.3278e+09, 9.3046e+09, 6.6121e+09);\n    var xyz = val * sqrt(6.283185307179586 * vr) * cos(pos * phase + shift) * exp(-(phase * phase) * vr);\n    xyz.x = xyz.x + 9.7470e-14 * sqrt(6.283185307179586 * 4.5282e+09) * cos(2.2399e+06 * phase + shift.x) * exp(-4.5282e+09 * phase * phase);\n    xyz = xyz / 1.0685e-7;\n    return NME_PBR_XYZ_TO_REC709 * xyz;\n}\nfn nme_pbr_evalIridescence(outsideIor: f32, eta2: f32, cosTheta1: f32, thickness: f32, baseF0: vec3<f32>) -> vec3<f32> {\n    let iridescenceIor = mix(outsideIor, eta2, smoothstep(0.0, 0.03, thickness));\n    let sinTheta2Sq = ((outsideIor / iridescenceIor) * (outsideIor / iridescenceIor)) * (1.0 - cosTheta1 * cosTheta1);\n    let cosTheta2Sq = 1.0 - sinTheta2Sq;\n    if (cosTheta2Sq < 0.0) { return vec3<f32>(1.0); }\n    let cosTheta2 = sqrt(cosTheta2Sq);\n    let r0 = nme_pbr_r0FromIor(iridescenceIor, outsideIor);\n    let r12 = nme_pbr_fresSchlick(cosTheta1, vec3<f32>(r0), vec3<f32>(1.0)).x;\n    let t121 = 1.0 - r12;\n    var phi12 = 0.0;\n    if (iridescenceIor < outsideIor) { phi12 = 3.141592653589793; }\n    let phi21 = 3.141592653589793 - phi12;\n    let baseIor = nme_pbr_iorFromAirF0(baseF0);\n    let r1 = nme_pbr_r0FromIor3(baseIor, iridescenceIor);\n    let r23 = nme_pbr_fresSchlick(cosTheta2, r1, vec3<f32>(1.0));\n    var phi23 = vec3<f32>(0.0);\n    if (baseIor.x < iridescenceIor) { phi23.x = 3.141592653589793; }\n    if (baseIor.y < iridescenceIor) { phi23.y = 3.141592653589793; }\n    if (baseIor.z < iridescenceIor) { phi23.z = 3.141592653589793; }\n    let opd = 2.0 * iridescenceIor * thickness * cosTheta2;\n    let phi = vec3<f32>(phi21) + phi23;\n    let r123 = clamp(vec3<f32>(r12) * r23, vec3<f32>(1e-5), vec3<f32>(0.9999));\n    let smallR123 = sqrt(r123);\n    let rs = (t121 * t121) * r23 / (vec3<f32>(1.0) - r123);\n    var outI = vec3<f32>(r12) + rs;\n    var cm = rs - vec3<f32>(t121);\n    for (var m: i32 = 1; m <= 2; m = m + 1) {\n        cm = cm * smallR123;\n        outI = outI + cm * (2.0 * nme_pbr_evalSensitivity(f32(m) * opd, f32(m) * phi));\n    }\n    return max(outI, vec3<f32>(0.0));\n}`;\n\nexport const emitter: BlockEmitter = {\n    className: \"IridescenceBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, state, _ctx) {\n        state.usesIridescence = true;\n        state.fragment.helpers.set(\"nme_pbr_iridescence_helpers\", IRIDESCENCE_HELPERS);\n        return { expr: `vec3<f32>(0.0)`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAUA,MAAM,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuDrB,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,OAAO,MAAM;AAC3C,UAAM,kBAAkB;AACxB,UAAM,SAAS,QAAQ,IAAI,+BAA+B,mBAAmB;AAC7E,WAAO,EAAE,MAAM,kBAAkB,MAAM,QAAA;AAAA,EAC3C;AACJ;"}