@multiplekex/shallot 0.2.5 → 0.3.0

package/src/standard/render/surface/shaders.ts

@@ -6,7 +6,7 @@ export function compileVertexBody(vertex?: string): string {
         : "return worldPos;";
 }
 
-export const STARS_WGSL = /* wgsl */ `
+const STARS_WGSL = /* wgsl */ `
 fn hashStar(p: vec2<f32>) -> f32 {
     var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
     p3 += dot(p3, p3.yzx + 33.33);
@@ -67,9 +67,66 @@ fn sampleStars(dir: vec3<f32>) -> vec3<f32> {
 }
 `;
 
-export { NOISE_WGSL } from "./noise";
+export const NOISE_WGSL = /* wgsl */ `
+fn hash2(p: vec2<f32>) -> f32 {
+    var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+fn value2d(p: vec2f, seed: vec2f) -> f32 {
+    let i = floor(p);
+    let f = fract(p);
+    let u = f * f * (3.0 - 2.0 * f);
+    return mix(
+        mix(fract(sin(dot(i, seed)) * 43758.5) * 2.0 - 1.0,
+            fract(sin(dot(i + vec2(1.0, 0.0), seed)) * 43758.5) * 2.0 - 1.0, u.x),
+        mix(fract(sin(dot(i + vec2(0.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0,
+            fract(sin(dot(i + vec2(1.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0, u.x), u.y);
+}
+
+fn simplex2(p: vec2<f32>) -> f32 {
+    let K1 = 0.366025404;
+    let K2 = 0.211324865;
+
+    let i = floor(p + (p.x + p.y) * K1);
+    let a = p - i + (i.x + i.y) * K2;
+
+    let o = select(vec2(0.0, 1.0), vec2(1.0, 0.0), a.x > a.y);
+    let b = a - o + K2;
+    let c = a - 1.0 + 2.0 * K2;
+
+    let h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), vec3(0.0));
+    let h4 = h * h * h * h;
+
+    let n = vec3(
+        dot(a, vec2(hash2(i) * 2.0 - 1.0, hash2(i + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(b, vec2(hash2(i + o) * 2.0 - 1.0, hash2(i + o + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(c, vec2(hash2(i + 1.0) * 2.0 - 1.0, hash2(i + vec2(1.0, 2.0)) * 2.0 - 1.0))
+    );
 
-export const MOON_WGSL = /* wgsl */ `
+    return dot(h4, n) * 70.0;
+}
+
+const FBM2_OCTAVES = 5;
+
+fn fbm2(p: vec2<f32>) -> f32 {
+    var value = 0.0;
+    var amplitude = 0.5;
+    var frequency = 1.0;
+    var pos = p;
+
+    for (var i = 0; i < FBM2_OCTAVES; i++) {
+        value += amplitude * simplex2(pos * frequency);
+        amplitude *= 0.5;
+        frequency *= 2.0;
+    }
+
+    return value;
+}
+`;
+
+const MOON_WGSL = /* wgsl */ `
 fn sampleMoon(dir: vec3<f32>) -> vec3<f32> {
     if (sky.moonParams.z <= 0.0) {
         return vec3(0.0);
@@ -125,7 +182,7 @@ fn sampleMoon(dir: vec3<f32>) -> vec3<f32> {
 }
 `;
 
-export const CLOUDS_WGSL = /* wgsl */ `
+const CLOUDS_WGSL = /* wgsl */ `
 fn sampleClouds(dir: vec3<f32>) -> vec4<f32> {
     if (sky.cloudParams.w <= 0.0 || dir.y < 0.01) {
         return vec4(0.0);
@@ -146,10 +203,8 @@ fn sampleClouds(dir: vec3<f32>) -> vec4<f32> {
 }
 `;
 
-const DEG_TO_RAD = Math.PI / 180;
-
 export const SKY_DIR_WGSL = /* wgsl */ `
-const DEG_TO_RAD: f32 = ${DEG_TO_RAD};
+const DEG_TO_RAD: f32 = 0.017453292;
 
 fn computeSkyDir(screenX: f32, screenY: f32) -> vec3<f32> {
     let width = scene.viewport.x;
@@ -248,10 +303,209 @@ fn applyHaze(color: vec3<f32>, dist: f32) -> vec3<f32> {
 }
 `;
 
+export const SHADOW_SAMPLE_WGSL = /* wgsl */ `
+const GOLDEN_ANGLE: f32 = 2.399963229728653;
+const CASCADE_BLEND_RANGE: f32 = 0.1;
+
+fn selectCascade(viewZ: f32) -> u32 {
+    if (viewZ < shadow.cascadeSplits.x) { return 0u; }
+    if (viewZ < shadow.cascadeSplits.y) { return 1u; }
+    if (viewZ < shadow.cascadeSplits.z) { return 2u; }
+    return 3u;
+}
+
+fn getCascadeViewProj(cascade: u32) -> mat4x4<f32> {
+    switch cascade {
+        case 0u: { return shadow.cascade0ViewProj; }
+        case 1u: { return shadow.cascade1ViewProj; }
+        case 2u: { return shadow.cascade2ViewProj; }
+        default: { return shadow.cascade3ViewProj; }
+    }
+}
+
+fn getCascadeTexelSize(cascade: u32) -> f32 {
+    switch cascade {
+        case 0u: { return shadow.cascadeTexelSizes.x; }
+        case 1u: { return shadow.cascadeTexelSizes.y; }
+        case 2u: { return shadow.cascadeTexelSizes.z; }
+        default: { return shadow.cascadeTexelSizes.w; }
+    }
+}
+
+fn getCascadeSplit(cascade: u32) -> f32 {
+    switch cascade {
+        case 0u: { return shadow.cascadeSplits.x; }
+        case 1u: { return shadow.cascadeSplits.y; }
+        case 2u: { return shadow.cascadeSplits.z; }
+        default: { return shadow.cascadeSplits.w; }
+    }
+}
+
+fn computeShadowBias(cascade: u32, NdotL: f32) -> f32 {
+    let baseBias = 0.0001 + f32(cascade) * 0.00005;
+    let clampedNdotL = max(NdotL, 0.01);
+    let slopeBias = baseBias * sqrt(1.0 - clampedNdotL * clampedNdotL) / clampedNdotL;
+    return baseBias + min(slopeBias, baseBias * 5.0);
+}
+
+fn computeNormalOffset(normal: vec3<f32>, lightDir: vec3<f32>, cascade: u32) -> vec3<f32> {
+    let NdotL = abs(dot(normal, lightDir));
+    let texelSize = getCascadeTexelSize(cascade);
+    let slopeScale = saturate(1.0 - NdotL);
+    return normal * texelSize * (1.0 + slopeScale * 2.0);
+}
+
+fn sampleShadowAtCascadeWithBias(worldPos: vec3<f32>, cascade: u32, bias: f32) -> f32 {
+    let lightPos = getCascadeViewProj(cascade) * vec4(worldPos, 1.0);
+    let ndc = lightPos.xyz / lightPos.w;
+
+    let inBounds = abs(ndc.x) <= 1.0 && abs(ndc.y) <= 1.0 && ndc.z >= 0.0 && ndc.z <= 1.0;
+
+    let safeNdc = clamp(ndc, vec3(-1.0, -1.0, 0.0), vec3(1.0, 1.0, 1.0));
+    var uv = safeNdc.xy * 0.5 + 0.5;
+    uv.y = 1.0 - uv.y;
+
+    let offset = vec2(f32(cascade % 2u) * 0.5, f32(cascade / 2u) * 0.5);
+    uv = uv * 0.5 + offset;
+
+    let sampled = textureSampleCompare(shadowMap, shadowSampler, uv, safeNdc.z - bias);
+    return select(1.0, sampled, inBounds);
+}
+
+fn sampleShadowOffsetWithBias(worldPos: vec3<f32>, cascade: u32, uvOffset: vec2<f32>, bias: f32) -> f32 {
+    let lightPos = getCascadeViewProj(cascade) * vec4(worldPos, 1.0);
+    let ndc = lightPos.xyz / lightPos.w;
+
+    let inBounds = abs(ndc.x) <= 1.0 && abs(ndc.y) <= 1.0 && ndc.z >= 0.0 && ndc.z <= 1.0;
+
+    let safeNdc = clamp(ndc, vec3(-1.0, -1.0, 0.0), vec3(1.0, 1.0, 1.0));
+    var uv = safeNdc.xy * 0.5 + 0.5;
+    uv.y = 1.0 - uv.y;
+
+    let cascadeOffset = vec2(f32(cascade % 2u) * 0.5, f32(cascade / 2u) * 0.5);
+    uv = uv * 0.5 + cascadeOffset + uvOffset;
+
+    let sampled = textureSampleCompare(shadowMap, shadowSampler, uv, safeNdc.z - bias);
+    return select(1.0, sampled, inBounds);
+}
+
+fn vogelDiskSample(sampleIndex: u32, samplesCount: u32, rotation: f32) -> vec2<f32> {
+    let angle = GOLDEN_ANGLE * f32(sampleIndex) + rotation;
+    let radius = sqrt((f32(sampleIndex) + 0.5) / f32(samplesCount));
+    return vec2(cos(angle), sin(angle)) * radius;
+}
+
+fn sampleShadowPCFAtCascade(worldPos: vec3<f32>, cascade: u32, softness: f32, samples: u32, bias: f32) -> f32 {
+    let atlasTexelSize = 1.0 / 2048.0;
+    var total = 0.0;
+
+    for (var i = 0u; i < samples; i++) {
+        let disk = vogelDiskSample(i, samples, 0.0);
+        let uvOffset = disk * softness * atlasTexelSize * 4.0;
+        total += sampleShadowOffsetWithBias(worldPos, cascade, uvOffset, bias);
+    }
+    return total / f32(samples);
+}
+
+fn computeCascadeBlend(viewZ: f32, cascade: u32) -> f32 {
+    if (cascade >= 3u) { return 0.0; }
+
+    let splitEnd = getCascadeSplit(cascade);
+    let blendStart = splitEnd * (1.0 - CASCADE_BLEND_RANGE);
+
+    if (viewZ < blendStart) { return 0.0; }
+    return saturate((viewZ - blendStart) / (splitEnd - blendStart));
+}
+
+fn distanceFade(viewZ: f32, maxDist: f32) -> f32 {
+    let fadeStart = maxDist * 0.9;
+    let fade = saturate((maxDist - viewZ) / (maxDist - fadeStart));
+    return select(fade, 1.0, viewZ <= fadeStart);
+}
+
+fn sampleShadow(worldPos: vec3<f32>, normal: vec3<f32>, viewZ: f32) -> f32 {
+    let lightDir = -scene.sunDirection.xyz;
+    let NdotL = max(dot(normal, lightDir), 0.0);
+
+    let cascade = selectCascade(viewZ);
+    let offset = computeNormalOffset(normal, lightDir, cascade);
+    let offsetPos = worldPos + offset;
+    let bias = computeShadowBias(cascade, NdotL);
+    let shadowCurrent = sampleShadowAtCascadeWithBias(offsetPos, cascade, bias);
+
+    let nextCascade = min(cascade + 1u, 3u);
+    let nextOffset = computeNormalOffset(normal, lightDir, nextCascade);
+    let nextOffsetPos = worldPos + nextOffset;
+    let nextBias = computeShadowBias(nextCascade, NdotL);
+    let shadowNext = sampleShadowAtCascadeWithBias(nextOffsetPos, nextCascade, nextBias);
+
+    let blendFactor = computeCascadeBlend(viewZ, cascade) * f32(cascade < 3u);
+    let cascadeShadow = mix(shadowCurrent, shadowNext, blendFactor);
+
+    let fade = distanceFade(viewZ, shadow.cascadeSplits.w);
+    return mix(1.0, cascadeShadow, fade);
+}
+
+fn sampleShadowPCF(worldPos: vec3<f32>, normal: vec3<f32>, viewZ: f32, softness: f32, samples: u32) -> f32 {
+    if (softness <= 0.0) {
+        return sampleShadow(worldPos, normal, viewZ);
+    }
+
+    let lightDir = -scene.sunDirection.xyz;
+    let NdotL = max(dot(normal, lightDir), 0.0);
+
+    let cascade = selectCascade(viewZ);
+    let offset = computeNormalOffset(normal, lightDir, cascade);
+    let offsetPos = worldPos + offset;
+    let bias = computeShadowBias(cascade, NdotL);
+    let shadowCurrent = sampleShadowPCFAtCascade(offsetPos, cascade, softness, samples, bias);
+
+    let nextCascade = min(cascade + 1u, 3u);
+    let nextOffset = computeNormalOffset(normal, lightDir, nextCascade);
+    let nextOffsetPos = worldPos + nextOffset;
+    let nextBias = computeShadowBias(nextCascade, NdotL);
+    let shadowNext = sampleShadowPCFAtCascade(nextOffsetPos, nextCascade, softness, samples, nextBias);
+
+    let blendFactor = computeCascadeBlend(viewZ, cascade) * f32(cascade < 3u);
+    let cascadeShadow = mix(shadowCurrent, shadowNext, blendFactor);
+
+    let fade = distanceFade(viewZ, shadow.cascadeSplits.w);
+    return mix(1.0, cascadeShadow, fade);
+}
+`;
+
+export const SPECULAR_WGSL = /* wgsl */ `
+const DIELECTRIC_F0: f32 = 0.04;
+
+fn blinnPhongSpecular(N: vec3<f32>, L: vec3<f32>, V: vec3<f32>, roughness: f32) -> f32 {
+    let H = normalize(L + V);
+    let NdotH = max(dot(N, H), 0.0);
+    let shininess = pow(2.0, (1.0 - roughness) * 10.0);
+    let intensity = (1.0 - roughness) * (1.0 - roughness);
+    return pow(NdotH, shininess) * intensity;
+}
+
+fn schlickFresnel(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
+    return F0 + (vec3(1.0) - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+fn computeF0Vec(baseColor: vec3<f32>, metallic: f32) -> vec3<f32> {
+    return mix(vec3(DIELECTRIC_F0), baseColor, metallic);
+}
+`;
+
 export const WGSL_LIGHTING_CALC = /* wgsl */ `
-let NdotL = max(dot(surface.normal, -scene.sunDirection.xyz), 0.0);
-let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-let sunDiffuse = scene.sunColor.rgb * NdotL;
+let V = normalize(scene.cameraWorld[3].xyz - surface.worldPos);
+let L = -scene.sunDirection.xyz;
+let NdotL = max(dot(surface.normal, L), 0.0);
+let NdotV = max(dot(surface.normal, V), 0.0);
+let F0 = computeF0Vec(surface.baseColor, surface.metallic);
+let F = schlickFresnel(NdotV, F0);
 let diffuseWeight = 1.0 - surface.metallic;
-let lighting = (ambient + sunDiffuse) * diffuseWeight;
+let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
+let sunDiffuse = scene.sunColor.rgb * NdotL * shadowFactor;
+let diffuseColor = surface.baseColor * (ambient + sunDiffuse) * diffuseWeight + surface.emission;
+let specTerm = blinnPhongSpecular(surface.normal, L, V, surface.roughness);
+let specular = scene.sunColor.rgb * specTerm * F * NdotL * shadowFactor;
+let litColor = diffuseColor + specular;
 `;

package/src/standard/render/surface/structs.ts

@@ -64,6 +64,16 @@ struct Data {
     _pad2: u32,
 }`;
 
+export const SHADOW_STRUCT_WGSL = /* wgsl */ `
+struct Shadow {
+    cascade0ViewProj: mat4x4<f32>,
+    cascade1ViewProj: mat4x4<f32>,
+    cascade2ViewProj: mat4x4<f32>,
+    cascade3ViewProj: mat4x4<f32>,
+    cascadeSplits: vec4<f32>,
+    cascadeTexelSizes: vec4<f32>,
+}`;
+
 export const WGSL_STRUCTS = /* wgsl */ `
 struct VertexInput {
     @location(0) position: vec3<f32>,

package/src/standard/tween/tween.ts

@@ -1,12 +1,4 @@
-import {
-    defineRelation,
-    registerPostLoadHook,
-    toCamelCase,
-    type State,
-    type System,
-    type Plugin,
-    type PostLoadContext,
-} from "../../core";
+import { defineRelation, toCamelCase, type State, type System, type Plugin } from "../../core";
 import {
     setTraits,
     getRegisteredComponent,
@@ -63,23 +55,17 @@ function bindFieldAccessor(
     return accessor;
 }
 
-function getFieldAccessor(bindingId: number): FieldAccessor | undefined {
-    return fieldAccessors.get(bindingId);
-}
+function getOrBindAccessor(tweenEid: number): FieldAccessor | undefined {
+    const existing = fieldAccessors.get(tweenEid);
+    if (existing) return existing;
 
-function parseTweenAttrs(attrs: Record<string, string>): Record<string, string> {
-    if (attrs._value) {
-        const parsed: Record<string, string> = {};
-        for (const part of attrs._value.split(";")) {
-            const colonIdx = part.indexOf(":");
-            if (colonIdx === -1) continue;
-            const key = part.slice(0, colonIdx).trim();
-            const value = part.slice(colonIdx + 1).trim();
-            if (key && value) parsed[key] = value;
-        }
-        return parsed;
-    }
-    return attrs;
+    const path = Tween.field[tweenEid];
+    if (!path) return undefined;
+
+    const parsed = resolveFieldPath(path);
+    if (!parsed) return undefined;
+
+    return bindFieldAccessor(tweenEid, parsed.component, parsed.field) ?? undefined;
 }
 
 export const TweenState = {
@@ -88,6 +74,29 @@ export const TweenState = {
     COMPLETE: 2,
 } as const;
 
+const fieldPaths = new Map<number, string>();
+
+function fieldProxy(): Record<number, string | undefined> {
+    return new Proxy({} as Record<number, string | undefined>, {
+        get(_, prop) {
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return undefined;
+            return fieldPaths.get(eid);
+        },
+        set(_, prop, value) {
+            const eid = Number(prop);
+            if (Number.isNaN(eid)) return false;
+            if (value === undefined || value === null) {
+                fieldPaths.delete(eid);
+            } else {
+                fieldPaths.set(eid, value as string);
+            }
+            fieldAccessors.delete(eid);
+            return true;
+        },
+    });
+}
+
 export const Tween = {
     state: [] as number[],
     from: [] as number[],
@@ -95,7 +104,8 @@ export const Tween = {
     duration: [] as number[],
     elapsed: [] as number[],
     delay: [] as number[],
-    easingIndex: [] as number[],
+    easing: [] as number[],
+    field: fieldProxy(),
 };
 
 setTraits(Tween, {
@@ -106,96 +116,18 @@ setTraits(Tween, {
         duration: 1,
         elapsed: 0,
         delay: 0,
-        easingIndex: 0,
+        easing: 0,
     }),
-    adapter: (attrs: Record<string, string>, eid: number) => {
-        const parsed = parseTweenAttrs(attrs);
-        const result: Record<string, number> = {};
-
-        if (parsed.duration) result.duration = parseFloat(parsed.duration);
-        if (parsed.delay) result.delay = parseFloat(parsed.delay);
-        if (parsed.easing) result.easingIndex = getEasingIndex(parsed.easing);
-
-        if (parsed.target) {
-            setupTweenFromXml(parsed, eid);
-        }
-
-        return result;
-    },
+    parse: { easing: getEasingIndex },
 });
 
-export const TweenTarget = defineRelation("tween-target", {
+export const TweenTarget = defineRelation("target", {
     exclusive: true,
 });
 
-interface ParsedTargetPath {
-    readonly entity: string;
-    readonly component: string;
-    readonly field: string;
-}
-
-function parseTargetPath(path: string): ParsedTargetPath | null {
-    if (!path.startsWith("@")) return null;
-
-    const rest = path.slice(1);
-    const firstDot = rest.indexOf(".");
-    if (firstDot === -1) return null;
-
-    const entity = rest.slice(0, firstDot);
-    const fieldPath = rest.slice(firstDot + 1);
-    const dotIndex = fieldPath.lastIndexOf(".");
-    if (dotIndex === -1) return null;
-
-    return {
-        entity,
-        component: fieldPath.slice(0, dotIndex),
-        field: fieldPath.slice(dotIndex + 1),
-    };
-}
-
-interface PendingTween {
-    readonly tweenEid: number;
-    readonly target: string;
-    readonly to: string;
-}
-
-let pendingXmlTweens: PendingTween[] = [];
-
-function setupTweenFromXml(attrs: Record<string, string>, tweenEid: number): void {
-    pendingXmlTweens.push({
-        tweenEid,
-        target: attrs.target,
-        to: attrs.to,
-    });
-}
-
-export function finalizePendingTweens(state: State, context: PostLoadContext): void {
-    for (const pending of pendingXmlTweens) {
-        const parsed = parseTargetPath(pending.target);
-        if (!parsed) continue;
-
-        const targetEid = context.getEntityByName(parsed.entity);
-        if (targetEid === null) continue;
-
-        const binding = bindFieldAccessor(pending.tweenEid, parsed.component, parsed.field);
-        if (!binding) continue;
-
-        state.addRelation(pending.tweenEid, TweenTarget, targetEid);
-        const toValue =
-            pending.to.startsWith("0x") || pending.to.startsWith("0X")
-                ? parseInt(pending.to, 16)
-                : parseFloat(pending.to);
-        if (!Number.isFinite(toValue)) {
-            throw new Error(`Tween has invalid 'to' value: "${pending.to}" (parsed as ${toValue})`);
-        }
-        Tween.to[pending.tweenEid] = toValue;
-    }
-    pendingXmlTweens = [];
-}
-
 export function captureFromValue(state: State, tweenEid: number): void {
     const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-    const binding = getFieldAccessor(tweenEid);
+    const binding = getOrBindAccessor(tweenEid);
 
     if (binding && targetEid >= 0) {
         Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
@@ -209,7 +141,7 @@ export function ensureResolved(state: State, tweenEid: number): void {
     if (duration > 0 && elapsed >= duration) return;
 
     const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-    const binding = getFieldAccessor(tweenEid);
+    const binding = getOrBindAccessor(tweenEid);
 
     if (binding && targetEid >= 0) {
         const toValue = Tween.to[tweenEid];
@@ -235,7 +167,7 @@ function updateTweens(state: State, dt: number): void {
         if (tweenState !== TweenState.PLAYING) continue;
 
         const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
-        const binding = getFieldAccessor(tweenEid);
+        const binding = getOrBindAccessor(tweenEid);
 
         if (Tween.elapsed[tweenEid] === 0 && binding && targetEid >= 0) {
             Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
@@ -253,7 +185,7 @@ function updateTweens(state: State, dt: number): void {
             );
         }
 
-        const easingFn = getEasing(Tween.easingIndex[tweenEid]);
+        const easingFn = getEasing(Tween.easing[tweenEid]);
         const easedProgress = easingFn(rawProgress);
 
         const from = Tween.from[tweenEid];
@@ -305,7 +237,7 @@ export function createTween(
     Tween.to[tweenEid] = options.to;
     Tween.duration[tweenEid] = options.duration ?? 1;
     Tween.elapsed[tweenEid] = 0;
-    Tween.easingIndex[tweenEid] = getEasingIndex(options.easing ?? "linear");
+    Tween.easing[tweenEid] = getEasingIndex(options.easing ?? "linear");
 
     return tweenEid;
 }
@@ -327,7 +259,4 @@ export const TweenPlugin: Plugin = {
     systems: [TweenSystem],
     components: { Tween, Sequence, Pause },
     relations: [TweenTarget],
-    initialize() {
-        registerPostLoadHook(finalizePendingTweens);
-    },
 };

package/src/standard/render/mesh/box.ts

@@ -1,20 +0,0 @@
-import type { MeshData } from "./index";
-
-export function createBox(): MeshData {
-    const vertices = new Float32Array([
-        -0.5, -0.5, 0.5, 0, 0, 1, 0.5, -0.5, 0.5, 0, 0, 1, 0.5, 0.5, 0.5, 0, 0, 1, -0.5, 0.5, 0.5,
-        0, 0, 1, 0.5, -0.5, -0.5, 0, 0, -1, -0.5, -0.5, -0.5, 0, 0, -1, -0.5, 0.5, -0.5, 0, 0, -1,
-        0.5, 0.5, -0.5, 0, 0, -1, -0.5, 0.5, 0.5, 0, 1, 0, 0.5, 0.5, 0.5, 0, 1, 0, 0.5, 0.5, -0.5,
-        0, 1, 0, -0.5, 0.5, -0.5, 0, 1, 0, -0.5, -0.5, -0.5, 0, -1, 0, 0.5, -0.5, -0.5, 0, -1, 0,
-        0.5, -0.5, 0.5, 0, -1, 0, -0.5, -0.5, 0.5, 0, -1, 0, 0.5, -0.5, 0.5, 1, 0, 0, 0.5, -0.5,
-        -0.5, 1, 0, 0, 0.5, 0.5, -0.5, 1, 0, 0, 0.5, 0.5, 0.5, 1, 0, 0, -0.5, -0.5, -0.5, -1, 0, 0,
-        -0.5, -0.5, 0.5, -1, 0, 0, -0.5, 0.5, 0.5, -1, 0, 0, -0.5, 0.5, -0.5, -1, 0, 0,
-    ]);
-
-    const indices = new Uint16Array([
-        0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15, 16, 17, 18,
-        16, 18, 19, 20, 21, 22, 20, 22, 23,
-    ]);
-
-    return { vertices, indices, vertexCount: 24, indexCount: 36 };
-}