@multiplekex/shallot 0.1.0

package/dist/standard/render/camera.js

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,158 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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"}