@multiplekex/shallot 0.1.0 → 0.1.1

package/dist/standard/render/camera.js

@@ -1,71 +0,0 @@
-import { setTraits as a } from "../../core/component.js";
-import { WorldTransform as m } from "../transforms/index.js";
-import { clearColor as n } from "./forward.js";
-import { perspective as p, invert as d, multiply as g } from "./scene.js";
-const C = {
-  Raster: 0,
-  Raytracing: 1
-}, v = {
-  Color: 0,
-  Depth: 1,
-  Normal: 2,
-  Material: 3,
-  Hit: 4
-}, e = {
-  fov: [],
-  near: [],
-  far: [],
-  active: [],
-  clearColor: [],
-  renderMode: [],
-  debugMode: []
-};
-a(e, {
-  defaults: () => ({
-    fov: 60,
-    near: 0.1,
-    far: 1e3,
-    active: 1,
-    clearColor: 1710618,
-    renderMode: C.Raster,
-    debugMode: v.Color
-  })
-});
-const M = {
-  exposure: []
-};
-a(M, {
-  defaults: () => ({ exposure: 1 })
-});
-const T = {}, b = {
-  strength: [],
-  inner: [],
-  outer: []
-};
-a(b, {
-  defaults: () => ({ strength: 0.5, inner: 0.4, outer: 0.8 })
-});
-function w(r) {
-  return {
-    r: (r >> 16 & 255) / 255,
-    g: (r >> 8 & 255) / 255,
-    b: (r & 255) / 255
-  };
-}
-function j(r, s, o, u) {
-  const t = w(e.clearColor[o]);
-  n.r = t.r, n.g = t.g, n.b = t.b;
-  const c = p(e.fov[o], u, e.near[o], e.far[o]), l = m.data.subarray(o * 16, o * 16 + 16), f = d(l), i = g(c, f);
-  r.queue.writeBuffer(s, 0, i), r.queue.writeBuffer(s, 64, l);
-}
-export {
-  e as Camera,
-  v as DebugMode,
-  T as FXAA,
-  C as RenderMode,
-  M as Tonemap,
-  b as Vignette,
-  w as unpackColor,
-  j as uploadCamera
-};
-//# sourceMappingURL=camera.js.map

package/dist/standard/render/camera.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"camera.js","sources":["../../../src/standard/render/camera.ts"],"sourcesContent":["import { setTraits } from \"../../core/component\";\nimport { WorldTransform } from \"../transforms\";\nimport { clearColor } from \"./forward\";\nimport { perspective, multiply, invert } from \"./scene\";\n\nexport const RenderMode = {\n    Raster: 0,\n    Raytracing: 1,\n} as const;\n\nexport const DebugMode = {\n    Color: 0,\n    Depth: 1,\n    Normal: 2,\n    Material: 3,\n    Hit: 4,\n} as const;\n\nexport const Camera = {\n    fov: [] as number[],\n    near: [] as number[],\n    far: [] as number[],\n    active: [] as number[],\n    clearColor: [] as number[],\n    renderMode: [] as number[],\n    debugMode: [] as number[],\n};\n\nsetTraits(Camera, {\n    defaults: () => ({\n        fov: 60,\n        near: 0.1,\n        far: 1000,\n        active: 1,\n        clearColor: 0x1a1a1a,\n        renderMode: RenderMode.Raster,\n        debugMode: DebugMode.Color,\n    }),\n});\n\nexport const Tonemap = {\n    exposure: [] as number[],\n};\n\nsetTraits(Tonemap, {\n    defaults: () => ({ exposure: 1.0 }),\n});\n\nexport const FXAA = {};\n\nexport const Vignette = {\n    strength: [] as number[],\n    inner: [] as number[],\n    outer: [] as number[],\n};\n\nsetTraits(Vignette, {\n    defaults: () => ({ strength: 0.5, inner: 0.4, outer: 0.8 }),\n});\n\nexport function unpackColor(packed: number): { r: number; g: number; b: number } {\n    return {\n        r: ((packed >> 16) & 0xff) / 255,\n        g: ((packed >> 8) & 0xff) / 255,\n        b: (packed & 0xff) / 255,\n    };\n}\n\nexport function uploadCamera(\n    device: GPUDevice,\n    buffer: GPUBuffer,\n    eid: number,\n    aspect: number\n): void {\n    const color = unpackColor(Camera.clearColor[eid]);\n    clearColor.r = color.r;\n    clearColor.g = color.g;\n    clearColor.b = color.b;\n\n    const proj = perspective(Camera.fov[eid], aspect, Camera.near[eid], Camera.far[eid]);\n    const world = WorldTransform.data.subarray(eid * 16, eid * 16 + 16);\n    const view = invert(world);\n    const viewProj = multiply(proj, view);\n\n    device.queue.writeBuffer(buffer, 0, viewProj as Float32Array<ArrayBuffer>);\n    device.queue.writeBuffer(buffer, 64, world);\n}\n"],"names":["RenderMode","DebugMode","Camera","setTraits","Tonemap","FXAA","Vignette","unpackColor","packed","uploadCamera","device","buffer","eid","aspect","color","clearColor","proj","perspective","world","WorldTransform","view","invert","viewProj","multiply"],"mappings":";;;;AAKO,MAAMA,IAAa;AAAA,EACtB,QAAQ;AAAA,EACR,YAAY;AAChB,GAEaC,IAAY;AAAA,EACrB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,KAAK;AACT,GAEaC,IAAS;AAAA,EAClB,KAAK,CAAA;AAAA,EACL,MAAM,CAAA;AAAA,EACN,KAAK,CAAA;AAAA,EACL,QAAQ,CAAA;AAAA,EACR,YAAY,CAAA;AAAA,EACZ,YAAY,CAAA;AAAA,EACZ,WAAW,CAAA;AACf;AAEAC,EAAUD,GAAQ;AAAA,EACd,UAAU,OAAO;AAAA,IACb,KAAK;AAAA,IACL,MAAM;AAAA,IACN,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,YAAYF,EAAW;AAAA,IACvB,WAAWC,EAAU;AAAA,EAAA;AAE7B,CAAC;AAEM,MAAMG,IAAU;AAAA,EACnB,UAAU,CAAA;AACd;AAEAD,EAAUC,GAAS;AAAA,EACf,UAAU,OAAO,EAAE,UAAU,EAAA;AACjC,CAAC;AAEM,MAAMC,IAAO,CAAA,GAEPC,IAAW;AAAA,EACpB,UAAU,CAAA;AAAA,EACV,OAAO,CAAA;AAAA,EACP,OAAO,CAAA;AACX;AAEAH,EAAUG,GAAU;AAAA,EAChB,UAAU,OAAO,EAAE,UAAU,KAAK,OAAO,KAAK,OAAO,IAAA;AACzD,CAAC;AAEM,SAASC,EAAYC,GAAqD;AAC7E,SAAO;AAAA,IACH,IAAKA,KAAU,KAAM,OAAQ;AAAA,IAC7B,IAAKA,KAAU,IAAK,OAAQ;AAAA,IAC5B,IAAIA,IAAS,OAAQ;AAAA,EAAA;AAE7B;AAEO,SAASC,EACZC,GACAC,GACAC,GACAC,GACI;AACJ,QAAMC,IAAQP,EAAYL,EAAO,WAAWU,CAAG,CAAC;AAChD,EAAAG,EAAW,IAAID,EAAM,GACrBC,EAAW,IAAID,EAAM,GACrBC,EAAW,IAAID,EAAM;AAErB,QAAME,IAAOC,EAAYf,EAAO,IAAIU,CAAG,GAAGC,GAAQX,EAAO,KAAKU,CAAG,GAAGV,EAAO,IAAIU,CAAG,CAAC,GAC7EM,IAAQC,EAAe,KAAK,SAASP,IAAM,IAAIA,IAAM,KAAK,EAAE,GAC5DQ,IAAOC,EAAOH,CAAK,GACnBI,IAAWC,EAASP,GAAMI,CAAI;AAEpC,EAAAV,EAAO,MAAM,YAAYC,GAAQ,GAAGW,CAAqC,GACzEZ,EAAO,MAAM,YAAYC,GAAQ,IAAIO,CAAK;AAC9C;"}

package/dist/standard/render/forward.d.ts

@@ -1,30 +0,0 @@
-import { ComputeNode } from '../compute';
-import { ShapeBatch } from './mesh';
-export declare const INDIRECT_SIZE = 20;
-export interface IndirectArgs {
-    indexCount: number;
-    instanceCount: number;
-    firstIndex: number;
-    baseVertex: number;
-    firstInstance: number;
-}
-export declare function createIndirectBuffer(device: GPUDevice, slotCount: number): GPUBuffer;
-export declare function writeIndirect(device: GPUDevice, buffer: GPUBuffer, slot: number, args: IndirectArgs): void;
-export declare const litShader = "\nstruct VertexInput {\n    @location(0) position: vec3<f32>,\n    @location(1) normal: vec3<f32>,\n    @builtin(instance_index) instance: u32,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n    @location(1) worldNormal: vec3<f32>,\n}\n\nstruct Scene {\n    viewProj: mat4x4<f32>,\n    cameraWorld: mat4x4<f32>,\n    ambientColor: vec4<f32>,\n    sunDirection: vec4<f32>,\n    sunColor: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> scene: Scene;\n@group(0) @binding(1) var<storage, read> entityIds: array<u32>;\n@group(0) @binding(2) var<storage, read> matrices: array<mat4x4<f32>>;\n@group(0) @binding(3) var<storage, read> colors: array<vec4<f32>>;\n@group(0) @binding(4) var<storage, read> sizes: array<vec4<f32>>;\n\n@vertex\nfn vs(input: VertexInput) -> VertexOutput {\n    let eid = entityIds[input.instance];\n    let world = matrices[eid];\n    let scaledPos = input.position * sizes[eid].xyz;\n    let worldPos = world * vec4<f32>(scaledPos, 1.0);\n    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);\n\n    var output: VertexOutput;\n    output.position = scene.viewProj * worldPos;\n    output.color = colors[eid];\n    output.worldNormal = worldNormal;\n    return output;\n}\n\n@fragment\nfn fs(input: VertexOutput) -> @location(0) vec4<f32> {\n    let normal = normalize(input.worldNormal);\n    let NdotL = max(dot(normal, -scene.sunDirection.xyz), 0.0);\n\n    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;\n    let diffuse = scene.sunColor.rgb * NdotL;\n    let lighting = ambient + diffuse;\n\n    return vec4<f32>(input.color.rgb * lighting, input.color.a);\n}\n";
-export declare function createForwardPipeline(device: GPUDevice, format: GPUTextureFormat): GPURenderPipeline;
-export declare const clearColor: {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-};
-export interface ForwardConfig {
-    scene: GPUBuffer;
-    matrices: GPUBuffer;
-    colors: GPUBuffer;
-    sizes: GPUBuffer;
-    indirect: GPUBuffer;
-    batches: Map<number, ShapeBatch>;
-}
-export declare function createForwardNode(config: ForwardConfig): ComputeNode;
-//# sourceMappingURL=forward.d.ts.map

package/dist/standard/render/forward.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"forward.d.ts","sourceRoot":"","sources":["../../../src/standard/render/forward.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAGzC,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,MAAM,WAAW,YAAY;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAUpF;AAED,wBAAgB,aAAa,CACzB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,GACnB,IAAI,CAYN;AAED,eAAO,MAAM,SAAS,gqDAqDrB,CAAC;AAEF,wBAAgB,qBAAqB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,GACzB,iBAAiB,CAiCnB;AAED,eAAO,MAAM,UAAU;;;;;CAAmC,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACpC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CA8DpE"}

package/dist/standard/render/forward.js

@@ -1,158 +0,0 @@
-import { DEPTH_FORMAT as p } from "./scene.js";
-const d = 20;
-function w(e, t) {
-  return e.createBuffer({
-    label: "indirect",
-    size: t * d,
-    usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-  });
-}
-function x(e, t, n, r) {
-  const s = n * d, u = new ArrayBuffer(d), o = new DataView(u);
-  o.setUint32(0, r.indexCount, !0), o.setUint32(4, r.instanceCount, !0), o.setUint32(8, r.firstIndex, !0), o.setInt32(12, r.baseVertex, !0), o.setUint32(16, r.firstInstance, !0), e.queue.writeBuffer(t, s, u);
-}
-const b = (
-  /* wgsl */
-  `
-struct VertexInput {
-    @location(0) position: vec3<f32>,
-    @location(1) normal: vec3<f32>,
-    @builtin(instance_index) instance: u32,
-}
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) color: vec4<f32>,
-    @location(1) worldNormal: vec3<f32>,
-}
-
-struct Scene {
-    viewProj: mat4x4<f32>,
-    cameraWorld: mat4x4<f32>,
-    ambientColor: vec4<f32>,
-    sunDirection: vec4<f32>,
-    sunColor: vec4<f32>,
-}
-
-@group(0) @binding(0) var<uniform> scene: Scene;
-@group(0) @binding(1) var<storage, read> entityIds: array<u32>;
-@group(0) @binding(2) var<storage, read> matrices: array<mat4x4<f32>>;
-@group(0) @binding(3) var<storage, read> colors: array<vec4<f32>>;
-@group(0) @binding(4) var<storage, read> sizes: array<vec4<f32>>;
-
-@vertex
-fn vs(input: VertexInput) -> VertexOutput {
-    let eid = entityIds[input.instance];
-    let world = matrices[eid];
-    let scaledPos = input.position * sizes[eid].xyz;
-    let worldPos = world * vec4<f32>(scaledPos, 1.0);
-    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);
-
-    var output: VertexOutput;
-    output.position = scene.viewProj * worldPos;
-    output.color = colors[eid];
-    output.worldNormal = worldNormal;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> @location(0) vec4<f32> {
-    let normal = normalize(input.worldNormal);
-    let NdotL = max(dot(normal, -scene.sunDirection.xyz), 0.0);
-
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-    let diffuse = scene.sunColor.rgb * NdotL;
-    let lighting = ambient + diffuse;
-
-    return vec4<f32>(input.color.rgb * lighting, input.color.a);
-}
-`
-);
-function m(e, t) {
-  const n = e.createShaderModule({ code: b });
-  return e.createRenderPipeline({
-    layout: "auto",
-    vertex: {
-      module: n,
-      entryPoint: "vs",
-      buffers: [
-        {
-          arrayStride: 24,
-          attributes: [
-            { shaderLocation: 0, offset: 0, format: "float32x3" },
-            { shaderLocation: 1, offset: 12, format: "float32x3" }
-          ]
-        }
-      ]
-    },
-    fragment: {
-      module: n,
-      entryPoint: "fs",
-      targets: [{ format: t }]
-    },
-    primitive: {
-      topology: "triangle-list",
-      cullMode: "back"
-    },
-    depthStencil: {
-      format: p,
-      depthWriteEnabled: !0,
-      depthCompare: "less"
-    }
-  });
-}
-const g = { r: 0.1, g: 0.1, b: 0.1, a: 1 };
-function h(e) {
-  let t = null;
-  const n = /* @__PURE__ */ new Map();
-  return {
-    id: "forward",
-    inputs: [],
-    outputs: [{ id: "scene", access: "write" }],
-    execute(r) {
-      const { device: s, encoder: u, format: o } = r, l = r.getTextureView("scene") ?? r.canvasView, f = r.getTextureView("depth");
-      t || (t = m(s, o));
-      const i = u.beginRenderPass({
-        colorAttachments: [
-          {
-            view: l,
-            clearValue: g,
-            loadOp: "clear",
-            storeOp: "store"
-          }
-        ],
-        depthStencilAttachment: {
-          view: f,
-          depthClearValue: 1,
-          depthLoadOp: "clear",
-          depthStoreOp: "store"
-        }
-      });
-      i.setPipeline(t);
-      for (const a of e.batches.values()) {
-        let c = n.get(a.index);
-        c || (c = s.createBindGroup({
-          layout: t.getBindGroupLayout(0),
-          entries: [
-            { binding: 0, resource: { buffer: e.scene } },
-            { binding: 1, resource: { buffer: a.entityIds } },
-            { binding: 2, resource: { buffer: e.matrices } },
-            { binding: 3, resource: { buffer: e.colors } },
-            { binding: 4, resource: { buffer: e.sizes } }
-          ]
-        }), n.set(a.index, c)), i.setBindGroup(0, c), i.setVertexBuffer(0, a.buffers.vertex), i.setIndexBuffer(a.buffers.index, "uint16"), i.drawIndexedIndirect(e.indirect, a.index * d);
-      }
-      i.end();
-    }
-  };
-}
-export {
-  d as INDIRECT_SIZE,
-  g as clearColor,
-  h as createForwardNode,
-  m as createForwardPipeline,
-  w as createIndirectBuffer,
-  b as litShader,
-  x as writeIndirect
-};
-//# sourceMappingURL=forward.js.map

package/dist/standard/render/forward.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"forward.js","sources":["../../../src/standard/render/forward.ts"],"sourcesContent":["import type { ComputeNode, ExecutionContext } from \"../compute\";\nimport type { ShapeBatch } from \"./mesh\";\nimport { DEPTH_FORMAT } from \"./scene\";\n\nexport const INDIRECT_SIZE = 20;\n\nexport interface IndirectArgs {\n    indexCount: number;\n    instanceCount: number;\n    firstIndex: number;\n    baseVertex: number;\n    firstInstance: number;\n}\n\nexport function createIndirectBuffer(device: GPUDevice, slotCount: number): GPUBuffer {\n    return device.createBuffer({\n        label: \"indirect\",\n        size: slotCount * INDIRECT_SIZE,\n        usage:\n            GPUBufferUsage.INDIRECT |\n            GPUBufferUsage.STORAGE |\n            GPUBufferUsage.COPY_DST |\n            GPUBufferUsage.COPY_SRC,\n    });\n}\n\nexport function writeIndirect(\n    device: GPUDevice,\n    buffer: GPUBuffer,\n    slot: number,\n    args: IndirectArgs\n): void {\n    const offset = slot * INDIRECT_SIZE;\n    const data = new ArrayBuffer(INDIRECT_SIZE);\n    const view = new DataView(data);\n\n    view.setUint32(0, args.indexCount, true);\n    view.setUint32(4, args.instanceCount, true);\n    view.setUint32(8, args.firstIndex, true);\n    view.setInt32(12, args.baseVertex, true);\n    view.setUint32(16, args.firstInstance, true);\n\n    device.queue.writeBuffer(buffer, offset, data);\n}\n\nexport const litShader = /* wgsl */ `\nstruct VertexInput {\n    @location(0) position: vec3<f32>,\n    @location(1) normal: vec3<f32>,\n    @builtin(instance_index) instance: u32,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n    @location(1) worldNormal: vec3<f32>,\n}\n\nstruct Scene {\n    viewProj: mat4x4<f32>,\n    cameraWorld: mat4x4<f32>,\n    ambientColor: vec4<f32>,\n    sunDirection: vec4<f32>,\n    sunColor: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> scene: Scene;\n@group(0) @binding(1) var<storage, read> entityIds: array<u32>;\n@group(0) @binding(2) var<storage, read> matrices: array<mat4x4<f32>>;\n@group(0) @binding(3) var<storage, read> colors: array<vec4<f32>>;\n@group(0) @binding(4) var<storage, read> sizes: array<vec4<f32>>;\n\n@vertex\nfn vs(input: VertexInput) -> VertexOutput {\n    let eid = entityIds[input.instance];\n    let world = matrices[eid];\n    let scaledPos = input.position * sizes[eid].xyz;\n    let worldPos = world * vec4<f32>(scaledPos, 1.0);\n    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);\n\n    var output: VertexOutput;\n    output.position = scene.viewProj * worldPos;\n    output.color = colors[eid];\n    output.worldNormal = worldNormal;\n    return output;\n}\n\n@fragment\nfn fs(input: VertexOutput) -> @location(0) vec4<f32> {\n    let normal = normalize(input.worldNormal);\n    let NdotL = max(dot(normal, -scene.sunDirection.xyz), 0.0);\n\n    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;\n    let diffuse = scene.sunColor.rgb * NdotL;\n    let lighting = ambient + diffuse;\n\n    return vec4<f32>(input.color.rgb * lighting, input.color.a);\n}\n`;\n\nexport function createForwardPipeline(\n    device: GPUDevice,\n    format: GPUTextureFormat\n): GPURenderPipeline {\n    const module = device.createShaderModule({ code: litShader });\n\n    return device.createRenderPipeline({\n        layout: \"auto\",\n        vertex: {\n            module,\n            entryPoint: \"vs\",\n            buffers: [\n                {\n                    arrayStride: 24,\n                    attributes: [\n                        { shaderLocation: 0, offset: 0, format: \"float32x3\" as const },\n                        { shaderLocation: 1, offset: 12, format: \"float32x3\" as const },\n                    ],\n                },\n            ],\n        },\n        fragment: {\n            module,\n            entryPoint: \"fs\",\n            targets: [{ format }],\n        },\n        primitive: {\n            topology: \"triangle-list\",\n            cullMode: \"back\",\n        },\n        depthStencil: {\n            format: DEPTH_FORMAT,\n            depthWriteEnabled: true,\n            depthCompare: \"less\",\n        },\n    });\n}\n\nexport const clearColor = { r: 0.1, g: 0.1, b: 0.1, a: 1 };\n\nexport interface ForwardConfig {\n    scene: GPUBuffer;\n    matrices: GPUBuffer;\n    colors: GPUBuffer;\n    sizes: GPUBuffer;\n    indirect: GPUBuffer;\n    batches: Map<number, ShapeBatch>;\n}\n\nexport function createForwardNode(config: ForwardConfig): ComputeNode {\n    let pipeline: GPURenderPipeline | null = null;\n    const bindGroups = new Map<number, GPUBindGroup>();\n\n    return {\n        id: \"forward\",\n        inputs: [],\n        outputs: [{ id: \"scene\", access: \"write\" }],\n\n        execute(ctx: ExecutionContext) {\n            const { device, encoder, format } = ctx;\n            const targetView = ctx.getTextureView(\"scene\") ?? ctx.canvasView;\n            const depthView = ctx.getTextureView(\"depth\")!;\n\n            if (!pipeline) {\n                pipeline = createForwardPipeline(device, format);\n            }\n\n            const pass = encoder.beginRenderPass({\n                colorAttachments: [\n                    {\n                        view: targetView,\n                        clearValue: clearColor,\n                        loadOp: \"clear\" as const,\n                        storeOp: \"store\" as const,\n                    },\n                ],\n                depthStencilAttachment: {\n                    view: depthView,\n                    depthClearValue: 1.0,\n                    depthLoadOp: \"clear\" as const,\n                    depthStoreOp: \"store\" as const,\n                },\n            });\n\n            pass.setPipeline(pipeline);\n\n            for (const batch of config.batches.values()) {\n                let bindGroup = bindGroups.get(batch.index);\n                if (!bindGroup) {\n                    bindGroup = device.createBindGroup({\n                        layout: pipeline.getBindGroupLayout(0),\n                        entries: [\n                            { binding: 0, resource: { buffer: config.scene } },\n                            { binding: 1, resource: { buffer: batch.entityIds } },\n                            { binding: 2, resource: { buffer: config.matrices } },\n                            { binding: 3, resource: { buffer: config.colors } },\n                            { binding: 4, resource: { buffer: config.sizes } },\n                        ],\n                    });\n                    bindGroups.set(batch.index, bindGroup);\n                }\n\n                pass.setBindGroup(0, bindGroup);\n                pass.setVertexBuffer(0, batch.buffers.vertex);\n                pass.setIndexBuffer(batch.buffers.index, \"uint16\");\n                pass.drawIndexedIndirect(config.indirect, batch.index * INDIRECT_SIZE);\n            }\n\n            pass.end();\n        },\n    };\n}\n"],"names":["INDIRECT_SIZE","createIndirectBuffer","device","slotCount","writeIndirect","buffer","slot","args","offset","data","view","litShader","createForwardPipeline","format","module","DEPTH_FORMAT","clearColor","createForwardNode","config","pipeline","bindGroups","ctx","encoder","targetView","depthView","pass","batch","bindGroup"],"mappings":"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"}

package/dist/standard/render/index.d.ts

@@ -1,22 +0,0 @@
-import { Plugin } from '../../core';
-import { ShapeBatch, MeshBuffers } from './mesh';
-import { PostProcessUniforms } from './postprocess';
-export * from './camera';
-export * from './light';
-export * from './mesh';
-export * from './scene';
-export * from './forward';
-export * from './postprocess';
-export interface RenderState {
-    scene: GPUBuffer;
-    matrices: GPUBuffer;
-    colors: GPUBuffer;
-    sizes: GPUBuffer;
-    indirect: GPUBuffer;
-    batches: Map<number, ShapeBatch>;
-    buffers: Map<number, MeshBuffers>;
-    postProcess: PostProcessUniforms;
-}
-export declare const Render: import('../..').ResourceKey<RenderState>;
-export declare const RenderPlugin: Plugin;
-//# sourceMappingURL=index.d.ts.map

package/dist/standard/render/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/standard/render/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;AAMxD,OAAO,EAMH,KAAK,UAAU,EACf,KAAK,WAAW,EACnB,MAAM,QAAQ,CAAC;AAGhB,OAAO,EAAyB,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEhF,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAE9B,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClC,WAAW,EAAE,mBAAmB,CAAC;CACpC;AAED,eAAO,MAAM,MAAM,0CAAkC,CAAC;AAsFtD,eAAO,MAAM,YAAY,EAAE,MAmD1B,CAAC"}

package/dist/standard/render/index.js

@@ -1,153 +0,0 @@
-import "bitecs";
-import { MAX_ENTITIES as f } from "../../core/state.js";
-import "../../core/builder.js";
-import { resource as w } from "../../core/resource.js";
-import "../../core/relation.js";
-import "../../core/math.js";
-import "fast-xml-parser";
-import { ComputePlugin as M, Compute as y } from "../compute/index.js";
-import { WorldTransform as P } from "../transforms/index.js";
-import { Vignette as c, FXAA as S, Tonemap as m, Camera as u, uploadCamera as I } from "./camera.js";
-import { DebugMode as te, RenderMode as ie, unpackColor as se } from "./camera.js";
-import { DirectionalLight as s, AmbientLight as p, packLightUniforms as R } from "./light.js";
-import { normalizeDirection as ce } from "./light.js";
-import { Mesh as C, collectByShape as E, MeshColors as T, MeshSizes as U, updateBatches as q } from "./mesh/index.js";
-import { MeshShape as pe, createGeometry as fe, createMeshBuffers as me } from "./mesh/index.js";
-import { createSceneBuffer as D, ensureRenderTextures as z } from "./scene.js";
-import { DEPTH_FORMAT as de, SCENE_UNIFORM_SIZE as le, invert as he, multiply as ge, perspective as Pe } from "./scene.js";
-import { createIndirectBuffer as O, createForwardNode as _ } from "./forward.js";
-import { INDIRECT_SIZE as Se, clearColor as Ce, createForwardPipeline as xe, litShader as Be, writeIndirect as ve } from "./forward.js";
-import { createPostProcessNode as A } from "./postprocess.js";
-const x = w("render"), N = {
-  group: "draw",
-  first: !0,
-  update(o) {
-    const e = x.from(o), n = y.from(o);
-    if (!e || !n || !o.canvas) return;
-    const { device: t, format: i, resources: a } = n, { width: d, height: l } = o.canvas;
-    z(
-      t,
-      i,
-      d,
-      l,
-      a.textures,
-      a.textureViews
-    );
-    for (const r of o.query([u]))
-      if (u.active[r]) {
-        I(t, e.scene, r, d / l), e.postProcess.tonemap = o.hasComponent(r, m), e.postProcess.tonemap && (e.postProcess.exposure = m.exposure[r]), e.postProcess.fxaa = o.hasComponent(r, S), o.hasComponent(r, c) && (e.postProcess.vignetteStrength = c.strength[r], e.postProcess.vignetteInner = c.inner[r], e.postProcess.vignetteOuter = c.outer[r]);
-        break;
-      }
-    let h = { color: 8947848, intensity: 1 }, g = {
-      color: 16777215,
-      intensity: 1,
-      directionX: -0.5,
-      directionY: -1,
-      directionZ: -0.5
-    };
-    for (const r of o.query([p])) {
-      h = {
-        color: p.color[r],
-        intensity: p.intensity[r]
-      };
-      break;
-    }
-    for (const r of o.query([s])) {
-      g = {
-        color: s.color[r],
-        intensity: s.intensity[r],
-        directionX: s.directionX[r],
-        directionY: s.directionY[r],
-        directionZ: s.directionZ[r]
-      };
-      break;
-    }
-    const B = R(h, g);
-    t.queue.writeBuffer(e.scene, 128, B), t.queue.writeBuffer(
-      e.matrices,
-      0,
-      P.data
-    );
-    const v = o.query([C, P]), b = E(v);
-    t.queue.writeBuffer(e.colors, 0, T.data), t.queue.writeBuffer(e.sizes, 0, U.data), q(t, b, e, e.indirect);
-  }
-}, ee = {
-  systems: [N],
-  components: { Camera: u, Mesh: C, AmbientLight: p, DirectionalLight: s, Tonemap: m, FXAA: S, Vignette: c },
-  dependencies: [M],
-  initialize(o) {
-    const e = y.from(o);
-    if (!e) return;
-    const { device: n } = e, t = (a) => n.createBuffer({
-      label: "property",
-      size: a,
-      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-    }), i = {
-      scene: D(n),
-      matrices: t(f * 64),
-      colors: t(f * 16),
-      sizes: t(f * 16),
-      indirect: O(n, 16),
-      batches: /* @__PURE__ */ new Map(),
-      buffers: /* @__PURE__ */ new Map(),
-      postProcess: {
-        tonemap: !1,
-        exposure: 1,
-        fxaa: !0,
-        vignetteStrength: 0,
-        vignetteInner: 0.4,
-        vignetteOuter: 0.8
-      }
-    };
-    o.setResource(x, i), e.graph.add(
-      _({
-        scene: i.scene,
-        matrices: i.matrices,
-        colors: i.colors,
-        sizes: i.sizes,
-        indirect: i.indirect,
-        batches: i.batches
-      })
-    ), e.graph.add(A(i.postProcess));
-  }
-};
-export {
-  p as AmbientLight,
-  u as Camera,
-  de as DEPTH_FORMAT,
-  te as DebugMode,
-  s as DirectionalLight,
-  S as FXAA,
-  Se as INDIRECT_SIZE,
-  C as Mesh,
-  T as MeshColors,
-  pe as MeshShape,
-  U as MeshSizes,
-  x as Render,
-  ie as RenderMode,
-  ee as RenderPlugin,
-  le as SCENE_UNIFORM_SIZE,
-  m as Tonemap,
-  c as Vignette,
-  Ce as clearColor,
-  E as collectByShape,
-  _ as createForwardNode,
-  xe as createForwardPipeline,
-  fe as createGeometry,
-  O as createIndirectBuffer,
-  me as createMeshBuffers,
-  A as createPostProcessNode,
-  D as createSceneBuffer,
-  z as ensureRenderTextures,
-  he as invert,
-  Be as litShader,
-  ge as multiply,
-  ce as normalizeDirection,
-  R as packLightUniforms,
-  Pe as perspective,
-  se as unpackColor,
-  q as updateBatches,
-  I as uploadCamera,
-  ve as writeIndirect
-};
-//# sourceMappingURL=index.js.map

package/dist/standard/render/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../src/standard/render/index.ts"],"sourcesContent":["import type { Plugin, State, System } from \"../../core\";\nimport { MAX_ENTITIES, resource } from \"../../core\";\nimport { Compute, ComputePlugin } from \"../compute\";\nimport { WorldTransform } from \"../transforms\";\nimport { Camera, Tonemap, FXAA, Vignette, uploadCamera } from \"./camera\";\nimport { AmbientLight, DirectionalLight, packLightUniforms } from \"./light\";\nimport {\n    Mesh,\n    MeshColors,\n    MeshSizes,\n    collectByShape,\n    updateBatches,\n    type ShapeBatch,\n    type MeshBuffers,\n} from \"./mesh\";\nimport { createSceneBuffer, ensureRenderTextures } from \"./scene\";\nimport { createForwardNode, createIndirectBuffer } from \"./forward\";\nimport { createPostProcessNode, type PostProcessUniforms } from \"./postprocess\";\n\nexport * from \"./camera\";\nexport * from \"./light\";\nexport * from \"./mesh\";\nexport * from \"./scene\";\nexport * from \"./forward\";\nexport * from \"./postprocess\";\n\nexport interface RenderState {\n    scene: GPUBuffer;\n    matrices: GPUBuffer;\n    colors: GPUBuffer;\n    sizes: GPUBuffer;\n    indirect: GPUBuffer;\n    batches: Map<number, ShapeBatch>;\n    buffers: Map<number, MeshBuffers>;\n    postProcess: PostProcessUniforms;\n}\n\nexport const Render = resource<RenderState>(\"render\");\n\nconst RenderSystem: System = {\n    group: \"draw\",\n    first: true,\n\n    update(state: State) {\n        const render = Render.from(state);\n        const compute = Compute.from(state);\n        if (!render || !compute || !state.canvas) return;\n\n        const { device, format, resources } = compute;\n        const { width, height } = state.canvas;\n\n        ensureRenderTextures(\n            device,\n            format,\n            width,\n            height,\n            resources.textures,\n            resources.textureViews\n        );\n\n        for (const eid of state.query([Camera])) {\n            if (Camera.active[eid]) {\n                uploadCamera(device, render.scene, eid, width / height);\n\n                render.postProcess.tonemap = state.hasComponent(eid, Tonemap);\n                if (render.postProcess.tonemap) {\n                    render.postProcess.exposure = Tonemap.exposure[eid];\n                }\n                render.postProcess.fxaa = state.hasComponent(eid, FXAA);\n                if (state.hasComponent(eid, Vignette)) {\n                    render.postProcess.vignetteStrength = Vignette.strength[eid];\n                    render.postProcess.vignetteInner = Vignette.inner[eid];\n                    render.postProcess.vignetteOuter = Vignette.outer[eid];\n                }\n                break;\n            }\n        }\n\n        let ambientData = { color: 0x888888, intensity: 1.0 };\n        let directionalData = {\n            color: 0xffffff,\n            intensity: 1.0,\n            directionX: -0.5,\n            directionY: -1.0,\n            directionZ: -0.5,\n        };\n\n        for (const eid of state.query([AmbientLight])) {\n            ambientData = {\n                color: AmbientLight.color[eid],\n                intensity: AmbientLight.intensity[eid],\n            };\n            break;\n        }\n\n        for (const eid of state.query([DirectionalLight])) {\n            directionalData = {\n                color: DirectionalLight.color[eid],\n                intensity: DirectionalLight.intensity[eid],\n                directionX: DirectionalLight.directionX[eid],\n                directionY: DirectionalLight.directionY[eid],\n                directionZ: DirectionalLight.directionZ[eid],\n            };\n            break;\n        }\n\n        const lightUniforms = packLightUniforms(ambientData, directionalData);\n        device.queue.writeBuffer(render.scene, 128, lightUniforms as Float32Array<ArrayBuffer>);\n\n        device.queue.writeBuffer(\n            render.matrices,\n            0,\n            WorldTransform.data as Float32Array<ArrayBuffer>\n        );\n\n        const meshEntities = state.query([Mesh, WorldTransform]);\n        const byShape = collectByShape(meshEntities);\n        device.queue.writeBuffer(render.colors, 0, MeshColors.data);\n        device.queue.writeBuffer(render.sizes, 0, MeshSizes.data);\n        updateBatches(device, byShape, render, render.indirect);\n    },\n};\n\nexport const RenderPlugin: Plugin = {\n    systems: [RenderSystem],\n    components: { Camera, Mesh, AmbientLight, DirectionalLight, Tonemap, FXAA, Vignette },\n    dependencies: [ComputePlugin],\n\n    initialize(state: State) {\n        const compute = Compute.from(state);\n        if (!compute) return;\n\n        const { device } = compute;\n\n        const createPropertyBuffer = (size: number) =>\n            device.createBuffer({\n                label: \"property\",\n                size,\n                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,\n            });\n\n        const renderState: RenderState = {\n            scene: createSceneBuffer(device),\n            matrices: createPropertyBuffer(MAX_ENTITIES * 64),\n            colors: createPropertyBuffer(MAX_ENTITIES * 16),\n            sizes: createPropertyBuffer(MAX_ENTITIES * 16),\n            indirect: createIndirectBuffer(device, 16),\n            batches: new Map(),\n            buffers: new Map(),\n            postProcess: {\n                tonemap: false,\n                exposure: 1.0,\n                fxaa: true,\n                vignetteStrength: 0,\n                vignetteInner: 0.4,\n                vignetteOuter: 0.8,\n            },\n        };\n\n        state.setResource(Render, renderState);\n\n        compute.graph.add(\n            createForwardNode({\n                scene: renderState.scene,\n                matrices: renderState.matrices,\n                colors: renderState.colors,\n                sizes: renderState.sizes,\n                indirect: renderState.indirect,\n                batches: renderState.batches,\n            })\n        );\n\n        compute.graph.add(createPostProcessNode(renderState.postProcess));\n    },\n};\n"],"names":["Render","resource","RenderSystem","state","render","compute","Compute","device","format","resources","width","height","ensureRenderTextures","eid","Camera","uploadCamera","Tonemap","FXAA","Vignette","ambientData","directionalData","AmbientLight","DirectionalLight","lightUniforms","packLightUniforms","WorldTransform","meshEntities","Mesh","byShape","collectByShape","MeshColors","MeshSizes","updateBatches","RenderPlugin","ComputePlugin","createPropertyBuffer","size","renderState","createSceneBuffer","MAX_ENTITIES","createIndirectBuffer","createForwardNode","createPostProcessNode"],"mappings":"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"}

package/dist/standard/render/light.d.ts

@@ -1,25 +0,0 @@
-export declare const AmbientLight: {
-    color: number[];
-    intensity: number[];
-};
-export declare const DirectionalLight: {
-    color: number[];
-    intensity: number[];
-    directionX: number[];
-    directionY: number[];
-    directionZ: number[];
-};
-export declare function normalizeDirection(x: number, y: number, z: number): [number, number, number];
-export interface AmbientLightData {
-    color: number;
-    intensity: number;
-}
-export interface DirectionalLightData {
-    color: number;
-    intensity: number;
-    directionX: number;
-    directionY: number;
-    directionZ: number;
-}
-export declare function packLightUniforms(ambient: AmbientLightData, directional: DirectionalLightData): Float32Array;
-//# sourceMappingURL=light.d.ts.map

package/dist/standard/render/light.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"light.d.ts","sourceRoot":"","sources":["../../../src/standard/render/light.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;WACR,MAAM,EAAE;eACJ,MAAM,EAAE;CAC5B,CAAC;AAMF,eAAO,MAAM,gBAAgB;WACZ,MAAM,EAAE;eACJ,MAAM,EAAE;gBACP,MAAM,EAAE;gBACR,MAAM,EAAE;gBACR,MAAM,EAAE;CAC7B,CAAC;AAYF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAM5F;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,iBAAiB,CAC7B,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,oBAAoB,GAClC,YAAY,CA0Bd"}

package/dist/standard/render/light.js

@@ -1,48 +0,0 @@
-import { setTraits as c } from "../../core/component.js";
-import { unpackColor as e } from "./camera.js";
-const f = {
-  color: [],
-  intensity: []
-};
-c(f, {
-  defaults: () => ({ color: 8947848, intensity: 1 })
-});
-const y = {
-  color: [],
-  intensity: [],
-  directionX: [],
-  directionY: [],
-  directionZ: []
-};
-c(y, {
-  defaults: () => ({
-    color: 16777215,
-    intensity: 1,
-    directionX: -0.5,
-    directionY: -1,
-    directionZ: -0.5
-  })
-});
-function g(o, n, t) {
-  const i = Math.sqrt(o * o + n * n + t * t);
-  return i < 1e-4 ? [0, -1, 0] : [o / i, n / i, t / i];
-}
-function a(o, n) {
-  const t = new Float32Array(12), i = e(o.color);
-  t[0] = i.r, t[1] = i.g, t[2] = i.b, t[3] = o.intensity;
-  const [s, d, u] = g(
-    n.directionX,
-    n.directionY,
-    n.directionZ
-  );
-  t[4] = s, t[5] = d, t[6] = u, t[7] = 0;
-  const r = e(n.color);
-  return t[8] = r.r * n.intensity, t[9] = r.g * n.intensity, t[10] = r.b * n.intensity, t[11] = 0, t;
-}
-export {
-  f as AmbientLight,
-  y as DirectionalLight,
-  g as normalizeDirection,
-  a as packLightUniforms
-};
-//# sourceMappingURL=light.js.map

package/dist/standard/render/light.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"light.js","sources":["../../../src/standard/render/light.ts"],"sourcesContent":["import { setTraits } from \"../../core/component\";\nimport { unpackColor } from \"./camera\";\n\nexport const AmbientLight = {\n    color: [] as number[],\n    intensity: [] as number[],\n};\n\nsetTraits(AmbientLight, {\n    defaults: () => ({ color: 0x888888, intensity: 1.0 }),\n});\n\nexport const DirectionalLight = {\n    color: [] as number[],\n    intensity: [] as number[],\n    directionX: [] as number[],\n    directionY: [] as number[],\n    directionZ: [] as number[],\n};\n\nsetTraits(DirectionalLight, {\n    defaults: () => ({\n        color: 0xffffff,\n        intensity: 1.0,\n        directionX: -0.5,\n        directionY: -1.0,\n        directionZ: -0.5,\n    }),\n});\n\nexport function normalizeDirection(x: number, y: number, z: number): [number, number, number] {\n    const len = Math.sqrt(x * x + y * y + z * z);\n    if (len < 0.0001) {\n        return [0, -1, 0];\n    }\n    return [x / len, y / len, z / len];\n}\n\nexport interface AmbientLightData {\n    color: number;\n    intensity: number;\n}\n\nexport interface DirectionalLightData {\n    color: number;\n    intensity: number;\n    directionX: number;\n    directionY: number;\n    directionZ: number;\n}\n\nexport function packLightUniforms(\n    ambient: AmbientLightData,\n    directional: DirectionalLightData\n): Float32Array {\n    const data = new Float32Array(12);\n\n    const ambientRgb = unpackColor(ambient.color);\n    data[0] = ambientRgb.r;\n    data[1] = ambientRgb.g;\n    data[2] = ambientRgb.b;\n    data[3] = ambient.intensity;\n\n    const [dx, dy, dz] = normalizeDirection(\n        directional.directionX,\n        directional.directionY,\n        directional.directionZ\n    );\n    data[4] = dx;\n    data[5] = dy;\n    data[6] = dz;\n    data[7] = 0;\n\n    const sunRgb = unpackColor(directional.color);\n    data[8] = sunRgb.r * directional.intensity;\n    data[9] = sunRgb.g * directional.intensity;\n    data[10] = sunRgb.b * directional.intensity;\n    data[11] = 0;\n\n    return data;\n}\n"],"names":["AmbientLight","setTraits","DirectionalLight","normalizeDirection","x","y","z","len","packLightUniforms","ambient","directional","data","ambientRgb","unpackColor","dx","dy","dz","sunRgb"],"mappings":";;AAGO,MAAMA,IAAe;AAAA,EACxB,OAAO,CAAA;AAAA,EACP,WAAW,CAAA;AACf;AAEAC,EAAUD,GAAc;AAAA,EACpB,UAAU,OAAO,EAAE,OAAO,SAAU,WAAW,EAAA;AACnD,CAAC;AAEM,MAAME,IAAmB;AAAA,EAC5B,OAAO,CAAA;AAAA,EACP,WAAW,CAAA;AAAA,EACX,YAAY,CAAA;AAAA,EACZ,YAAY,CAAA;AAAA,EACZ,YAAY,CAAA;AAChB;AAEAD,EAAUC,GAAkB;AAAA,EACxB,UAAU,OAAO;AAAA,IACb,OAAO;AAAA,IACP,WAAW;AAAA,IACX,YAAY;AAAA,IACZ,YAAY;AAAA,IACZ,YAAY;AAAA,EAAA;AAEpB,CAAC;AAEM,SAASC,EAAmBC,GAAWC,GAAWC,GAAqC;AAC1F,QAAMC,IAAM,KAAK,KAAKH,IAAIA,IAAIC,IAAIA,IAAIC,IAAIA,CAAC;AAC3C,SAAIC,IAAM,OACC,CAAC,GAAG,IAAI,CAAC,IAEb,CAACH,IAAIG,GAAKF,IAAIE,GAAKD,IAAIC,CAAG;AACrC;AAeO,SAASC,EACZC,GACAC,GACY;AACZ,QAAMC,IAAO,IAAI,aAAa,EAAE,GAE1BC,IAAaC,EAAYJ,EAAQ,KAAK;AAC5C,EAAAE,EAAK,CAAC,IAAIC,EAAW,GACrBD,EAAK,CAAC,IAAIC,EAAW,GACrBD,EAAK,CAAC,IAAIC,EAAW,GACrBD,EAAK,CAAC,IAAIF,EAAQ;AAElB,QAAM,CAACK,GAAIC,GAAIC,CAAE,IAAIb;AAAA,IACjBO,EAAY;AAAA,IACZA,EAAY;AAAA,IACZA,EAAY;AAAA,EAAA;AAEhB,EAAAC,EAAK,CAAC,IAAIG,GACVH,EAAK,CAAC,IAAII,GACVJ,EAAK,CAAC,IAAIK,GACVL,EAAK,CAAC,IAAI;AAEV,QAAMM,IAASJ,EAAYH,EAAY,KAAK;AAC5C,SAAAC,EAAK,CAAC,IAAIM,EAAO,IAAIP,EAAY,WACjCC,EAAK,CAAC,IAAIM,EAAO,IAAIP,EAAY,WACjCC,EAAK,EAAE,IAAIM,EAAO,IAAIP,EAAY,WAClCC,EAAK,EAAE,IAAI,GAEJA;AACX;"}

package/dist/standard/render/mesh/box.d.ts

@@ -1,3 +0,0 @@
-import { MeshData } from './index';
-export declare function createBox(): MeshData;
-//# sourceMappingURL=box.d.ts.map

package/dist/standard/render/mesh/box.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"box.d.ts","sourceRoot":"","sources":["../../../../src/standard/render/mesh/box.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,wBAAgB,SAAS,IAAI,QAAQ,CAiBpC"}