@mavonengine/core 0.0.2

package/dist/Prefab/Water/Water.js

@@ -0,0 +1,192 @@
+import { WithEditorHelper } from '../../Editor/WithEditorHelper';
+import Game from '../../Game';
+import GameObject from '../../World/GameObject';
+import { Color, EqualStencilFunc, IncrementStencilOp, Mesh, PlaneGeometry, ShaderMaterial, Vector3 as Vec3, Vector2 } from 'three';
+import FragmentShader from './Fragment.glsl';
+import VertexShader from './Vertex.glsl';
+import WaterManager from './WaterManager';
+const MAX_PUSH_POINTS = 150;
+const DEFAULT_LOD = {
+    segments: [512, 128, 32],
+    distances: [40, 60],
+};
+/**
+ * https://threejs-journey.com/lessons/raging-sea
+ */
+export default class Water extends WithEditorHelper(GameObject) {
+    constructor(position, size, sectionCount = 1, lod = DEFAULT_LOD) {
+        super(undefined, position);
+        this.sections = [];
+        this.cullPadding = 0;
+        this.lodConfig = lod;
+        this.sectionCount = sectionCount;
+        this.material = new ShaderMaterial({
+            transparent: true,
+            stencilWrite: true,
+            stencilFunc: EqualStencilFunc,
+            stencilRef: 0,
+            stencilZPass: IncrementStencilOp,
+            fragmentShader: FragmentShader,
+            vertexShader: VertexShader,
+            uniforms: {
+                uTime: { value: 0 },
+                uBigWavesElevation: { value: 0.380 },
+                uBigWavesFrequency: { value: new Vector2(0.326, 0.978) },
+                uBigWavesSpeed: { value: 1.0 },
+                uDepthColor: { value: new Color('#186691') },
+                uSurfaceColor: { value: new Color('#9bd8ff') },
+                uColorOffset: { value: 0.380 },
+                uColorMultiplier: { value: 0.761 },
+                pushPositions: {
+                    value: Array.from({ length: MAX_PUSH_POINTS }, () => new Vec3()),
+                },
+                pushRadii: {
+                    value: Array.from({ length: MAX_PUSH_POINTS }).fill(0),
+                },
+                uSunDirection: { value: new Vec3(0, 1, 0) },
+                uSunReflectionStrength: { value: 1.0 },
+            },
+        });
+        const sectionSize = size / sectionCount;
+        for (let gx = 0; gx < sectionCount; gx++) {
+            for (let gz = 0; gz < sectionCount; gz++) {
+                const offsetX = (gx - (sectionCount - 1) / 2) * sectionSize;
+                const offsetZ = (gz - (sectionCount - 1) / 2) * sectionSize;
+                const farSegments = Math.max(1, Math.round(lod.segments[2] / sectionCount));
+                const geoSize = sectionSize * 1.02;
+                const geometry = new PlaneGeometry(geoSize, geoSize, farSegments, farSegments);
+                const mesh = new Mesh(geometry, this.material);
+                mesh.position.set(this.position.x + offsetX, this.position.y, this.position.z + offsetZ);
+                mesh.rotation.x = -Math.PI * 0.5;
+                this.sections.push({ mesh, sectionSize, currentLOD: 2 });
+                Game.instance().scene.add(mesh);
+            }
+        }
+        this.registerEditorHelper(position, 'Water', {
+            addBindings: folder => WaterManager.instance?.addBindings(folder),
+        });
+        for (const section of this.sections)
+            this.tagWithHelper(section.mesh);
+        this.addDebugTools();
+    }
+    addDebugTools() {
+        if (!Game.instance().debug.active || !WaterManager.instance)
+            return;
+        WaterManager.instance.uBigWavesElevationController?.on('change', (ev) => {
+            this.material.uniforms.uBigWavesElevation.value = ev.value;
+        });
+        WaterManager.instance.uBigWavesFrequencyControllerX?.on('change', (ev) => {
+            this.material.uniforms.uBigWavesFrequency.value.setX(ev.value);
+        });
+        WaterManager.instance.uBigWavesFrequencyControllerY?.on('change', (ev) => {
+            this.material.uniforms.uBigWavesFrequency.value.setY(ev.value);
+        });
+        WaterManager.instance.uBigWavesSpeedController?.on('change', (ev) => {
+            this.material.uniforms.uBigWavesSpeed.value = ev.value;
+        });
+        WaterManager.instance.uDepthColorController?.on('change', (ev) => {
+            this.material.uniforms.uDepthColor.value = new Color(ev.value);
+        });
+        WaterManager.instance.uSurfaceColorController?.on('change', (ev) => {
+            this.material.uniforms.uSurfaceColor.value = new Color(ev.value);
+        });
+        WaterManager.instance.uColorOffsetController?.on('change', (ev) => {
+            this.material.uniforms.uColorOffset.value = ev.value;
+        });
+        WaterManager.instance.uColorMultiplierController?.on('change', (ev) => {
+            this.material.uniforms.uColorMultiplier.value = ev.value;
+        });
+        WaterManager.instance.uSunReflectionStrengthController?.on('change', (ev) => {
+            this.material.uniforms.uSunReflectionStrength.value = ev.value;
+        });
+    }
+    swapGeometry(section, targetLOD) {
+        const segments = Math.max(1, Math.round(this.lodConfig.segments[targetLOD] / this.sectionCount));
+        const oldGeometry = section.mesh.geometry;
+        const geoSize = section.sectionSize * 1.05;
+        const newGeometry = new PlaneGeometry(geoSize, geoSize, segments, segments);
+        if (this.cullHeight) {
+            this.cullGeometry(newGeometry, section.mesh, this.cullHeight, this.cullPadding);
+        }
+        section.mesh.geometry = newGeometry;
+        section.currentLOD = targetLOD;
+        oldGeometry.dispose();
+    }
+    cullGeometry(geometry, mesh, getHeight, padding) {
+        const position = geometry.attributes.position;
+        const index = geometry.index;
+        if (!index)
+            return;
+        const culled = new Uint8Array(position.count);
+        for (let i = 0; i < position.count; i++) {
+            const worldX = position.getX(i) + mesh.position.x;
+            const worldZ = -position.getY(i) + mesh.position.z;
+            const terrainHeight = getHeight(worldX, worldZ);
+            if (terrainHeight - padding > mesh.position.y) {
+                culled[i] = 1;
+            }
+        }
+        const oldIndices = index.array;
+        const newIndices = [];
+        for (let i = 0; i < oldIndices.length; i += 3) {
+            const a = oldIndices[i];
+            const b = oldIndices[i + 1];
+            const c = oldIndices[i + 2];
+            if (!culled[a] || !culled[b] || !culled[c]) {
+                newIndices.push(a, b, c);
+            }
+        }
+        geometry.setIndex(newIndices);
+    }
+    /**
+     * Removes triangles where all 3 vertices are beneath the surface returned by
+     * `getHeight`. The callback is stored so culling is automatically re-applied
+     * whenever a section swaps LOD.
+     */
+    cullVertices(getHeight, padding = 0) {
+        this.cullHeight = getHeight;
+        this.cullPadding = padding;
+        for (const section of this.sections) {
+            this.cullGeometry(section.mesh.geometry, section.mesh, getHeight, padding);
+        }
+    }
+    setPushPoints(points) {
+        for (let i = 0; i < MAX_PUSH_POINTS; i++) {
+            if (points[i]) {
+                this.material.uniforms.pushPositions.value[i].copy(points[i].position);
+                this.material.uniforms.pushRadii.value[i] = points[i].radius;
+            }
+        }
+    }
+    update(_delta) {
+        this.material.uniforms.uTime.value = Game.instance().clock.elapsedTime;
+        if (WaterManager.instance) {
+            this.material.uniforms.uSunDirection.value.copy(WaterManager.instance.sunPosition);
+        }
+        const cameraPos = Game.instance().camera.instance.position;
+        for (const section of this.sections) {
+            const distance = cameraPos.distanceTo(section.mesh.position);
+            let targetLOD;
+            if (distance < this.lodConfig.distances[0]) {
+                targetLOD = 0;
+            }
+            else if (distance < this.lodConfig.distances[1]) {
+                targetLOD = 1;
+            }
+            else {
+                targetLOD = 2;
+            }
+            if (targetLOD !== section.currentLOD) {
+                this.swapGeometry(section, targetLOD);
+            }
+        }
+    }
+    destroy() {
+        for (const section of this.sections) {
+            section.mesh.geometry.dispose();
+            Game.instance().scene.remove(section.mesh);
+        }
+        this.material.dispose();
+        super.destroy();
+    }
+}

package/dist/Prefab/Water/WaterManager.cjs

@@ -0,0 +1,146 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WaterManager_exports = {};
+__export(WaterManager_exports, {
+  default: () => WaterManager
+});
+module.exports = __toCommonJS(WaterManager_exports);
+var import_Game = __toESM(require("../../Game"), 1);
+var import_three = require("three");
+class WaterManager {
+  constructor() {
+    this.uBigwavesElevation = 0.2;
+    this.uBigwavesFrequency = new import_three.Vector2(4, 1.5);
+    this.uBigWavesSpeed = 0.75;
+    this.uSurfaceColor = "#9bd8ff";
+    this.uDepthColor = "#186691";
+    this.uColorOffset = 0.08;
+    this.uColorMultiplier = 5;
+    this.sunPosition = new import_three.Vector3(0, 1, 0);
+    this.uSunReflectionStrength = 1;
+    this.waters = [];
+    WaterManager.instance = this;
+    if (import_Game.default.instance().debug.active || import_Game.default.instance().editor) {
+      const waterFolder = import_Game.default.instance().debug.ui?.addFolder({ title: "Water" });
+      if (waterFolder)
+        this.addBindings(waterFolder);
+    }
+  }
+  static init() {
+    WaterManager.instance = new WaterManager();
+  }
+  addBindings(folder) {
+    this.uBigWavesElevationController = folder.addBinding(this, "uBigwavesElevation", {
+      min: 0,
+      max: 1,
+      step: 1e-3,
+      label: "Height"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesElevation.value = value;
+      });
+    });
+    this.uBigWavesFrequencyControllerX = folder.addBinding(this.uBigwavesFrequency, "x", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "FrequencyX"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesFrequency.value.setX(value);
+      });
+    });
+    this.uBigWavesFrequencyControllerY = folder.addBinding(this.uBigwavesFrequency, "y", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "FrequencyY"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesFrequency.value.setY(value);
+      });
+    });
+    this.uBigWavesSpeedController = folder.addBinding(this, "uBigWavesSpeed", {
+      min: 0,
+      max: 4,
+      step: 1e-3,
+      label: "Speed"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uBigWavesSpeed.value = value;
+      });
+    });
+    this.uSurfaceColorController = folder.addBinding(this, "uSurfaceColor", {
+      label: "Surface Color",
+      view: "color"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uSurfaceColor.value.set(value);
+      });
+    });
+    this.uDepthColorController = folder.addBinding(this, "uDepthColor", {
+      label: "Depth Color",
+      view: "color"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uDepthColor.value.set(value);
+      });
+    });
+    this.uColorOffsetController = folder.addBinding(this, "uColorOffset", {
+      min: 0,
+      max: 1,
+      step: 1e-3,
+      label: "uColorOffset"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uColorOffset.value = value;
+      });
+    });
+    this.uColorMultiplierController = folder.addBinding(this, "uColorMultiplier", {
+      min: 0,
+      max: 10,
+      step: 1e-3,
+      label: "uColorMultiplier"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uColorMultiplier.value = value;
+      });
+    });
+    this.uSunReflectionStrengthController = folder.addBinding(this, "uSunReflectionStrength", {
+      min: 0,
+      max: 3,
+      step: 0.01,
+      label: "Sun Reflection"
+    }).on("change", ({ value }) => {
+      this.waters.forEach((w) => {
+        w.material.uniforms.uSunReflectionStrength.value = value;
+      });
+    });
+  }
+}

package/dist/Prefab/Water/WaterManager.d.ts

@@ -0,0 +1,28 @@
+import type { BindingApi, ContainerApi } from '@tweakpane/core';
+import type Water from './Water';
+import { Vector2, Vector3 } from 'three';
+export default class WaterManager {
+    uBigwavesElevation: number;
+    uBigWavesElevationController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uBigwavesFrequency: Vector2;
+    uBigWavesFrequencyControllerX: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uBigWavesFrequencyControllerY: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uBigWavesSpeed: number;
+    uBigWavesSpeedController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uSurfaceColor: string;
+    uSurfaceColorController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uDepthColor: string;
+    uDepthColorController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uColorOffset: number;
+    uColorOffsetController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    uColorMultiplier: number;
+    uColorMultiplierController: BindingApi<unknown, this['uBigwavesElevation'], any> | undefined;
+    sunPosition: Vector3;
+    uSunReflectionStrength: number;
+    uSunReflectionStrengthController: BindingApi<unknown, this['uSunReflectionStrength'], any> | undefined;
+    waters: Water[];
+    static instance?: WaterManager;
+    static init(): void;
+    constructor();
+    addBindings(folder: ContainerApi): void;
+}

package/dist/Prefab/Water/WaterManager.js

@@ -0,0 +1,113 @@
+import Game from '../../Game';
+import { Vector2, Vector3 } from 'three';
+export default class WaterManager {
+    static init() {
+        WaterManager.instance = new WaterManager();
+    }
+    constructor() {
+        this.uBigwavesElevation = 0.2;
+        this.uBigwavesFrequency = new Vector2(4, 1.5);
+        this.uBigWavesSpeed = 0.75;
+        this.uSurfaceColor = '#9bd8ff';
+        this.uDepthColor = '#186691';
+        this.uColorOffset = 0.08;
+        this.uColorMultiplier = 5.0;
+        this.sunPosition = new Vector3(0, 1, 0);
+        this.uSunReflectionStrength = 1.0;
+        this.waters = [];
+        WaterManager.instance = this;
+        if (Game.instance().debug.active || Game.instance().editor) {
+            const waterFolder = Game.instance().debug.ui?.addFolder({ title: 'Water' });
+            if (waterFolder)
+                this.addBindings(waterFolder);
+        }
+    }
+    addBindings(folder) {
+        this.uBigWavesElevationController = folder.addBinding(this, 'uBigwavesElevation', {
+            min: 0,
+            max: 1,
+            step: 0.001,
+            label: 'Height',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uBigWavesElevation.value = value;
+            });
+        });
+        this.uBigWavesFrequencyControllerX = folder.addBinding(this.uBigwavesFrequency, 'x', {
+            min: 0,
+            max: 10,
+            step: 0.001,
+            label: 'FrequencyX',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uBigWavesFrequency.value.setX(value);
+            });
+        });
+        this.uBigWavesFrequencyControllerY = folder.addBinding(this.uBigwavesFrequency, 'y', {
+            min: 0,
+            max: 10,
+            step: 0.001,
+            label: 'FrequencyY',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uBigWavesFrequency.value.setY(value);
+            });
+        });
+        this.uBigWavesSpeedController = folder.addBinding(this, 'uBigWavesSpeed', {
+            min: 0,
+            max: 4,
+            step: 0.001,
+            label: 'Speed',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uBigWavesSpeed.value = value;
+            });
+        });
+        this.uSurfaceColorController = folder.addBinding(this, 'uSurfaceColor', {
+            label: 'Surface Color',
+            view: 'color',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uSurfaceColor.value.set(value);
+            });
+        });
+        this.uDepthColorController = folder.addBinding(this, 'uDepthColor', {
+            label: 'Depth Color',
+            view: 'color',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uDepthColor.value.set(value);
+            });
+        });
+        this.uColorOffsetController = folder.addBinding(this, 'uColorOffset', {
+            min: 0,
+            max: 1,
+            step: 0.001,
+            label: 'uColorOffset',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uColorOffset.value = value;
+            });
+        });
+        this.uColorMultiplierController = folder.addBinding(this, 'uColorMultiplier', {
+            min: 0,
+            max: 10,
+            step: 0.001,
+            label: 'uColorMultiplier',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uColorMultiplier.value = value;
+            });
+        });
+        this.uSunReflectionStrengthController = folder.addBinding(this, 'uSunReflectionStrength', {
+            min: 0,
+            max: 3,
+            step: 0.01,
+            label: 'Sun Reflection',
+        }).on('change', ({ value }) => {
+            this.waters.forEach((w) => {
+                w.material.uniforms.uSunReflectionStrength.value = value;
+            });
+        });
+    }
+}

package/dist/Renderer/AssetRenderer.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AssetRenderer_exports = {};
+__export(AssetRenderer_exports, {
+  default: () => AssetRenderer
+});
+module.exports = __toCommonJS(AssetRenderer_exports);
+var import_three = require("three");
+var import_webgpu = require("three/webgpu");
+var import_Game = __toESM(require("../Game"), 1);
+const _AssetRenderer = class _AssetRenderer {
+  constructor(key) {
+    this.item = import_Game.default.instance().resources.items[key];
+    this.initRenderer();
+    if ("scene" in this.item) {
+      _AssetRenderer.previewScene.add(this.item.scene);
+      this.adjustCameraToModel(this.item.scene);
+    }
+  }
+  initRenderer() {
+    if (_AssetRenderer.initialized)
+      return;
+    _AssetRenderer.previewRenderer.setSize(100, 100);
+    const light = new import_webgpu.DirectionalLight(16777215, 3);
+    light.position.set(5, 5, 5);
+    _AssetRenderer.previewScene.add(light);
+    const ambientLight = new import_webgpu.DirectionalLight(16777215, 4);
+    ambientLight.position.set(-5, -5, -5);
+    _AssetRenderer.previewScene.add(ambientLight);
+    _AssetRenderer.initialized = true;
+  }
+  adjustCameraToModel(model) {
+    const box = new import_webgpu.Box3().setFromObject(model);
+    const size = new import_webgpu.Vector3();
+    const center = new import_webgpu.Vector3();
+    box.getSize(size);
+    box.getCenter(center);
+    const maxDim = Math.max(size.x, size.y, size.z);
+    const fov = _AssetRenderer.previewCamera.fov * (Math.PI / 180);
+    const cameraZ = maxDim / (2 * Math.tan(fov / 2));
+    _AssetRenderer.previewCamera.position.set(center.x, center.y, center.z + cameraZ * 1.5);
+    _AssetRenderer.previewCamera.lookAt(center);
+    _AssetRenderer.previewCamera.near = 0.1;
+    _AssetRenderer.previewCamera.far = cameraZ + maxDim * 2;
+    _AssetRenderer.previewCamera.updateProjectionMatrix();
+  }
+  render() {
+    if ("scene" in this.item === false)
+      return;
+    _AssetRenderer.previewRenderer.render(_AssetRenderer.previewScene, _AssetRenderer.previewCamera);
+    _AssetRenderer.previewScene.remove(this.item.scene);
+    return _AssetRenderer.previewRenderer.domElement.toDataURL();
+  }
+};
+_AssetRenderer.previewScene = new import_webgpu.Scene();
+_AssetRenderer.previewRenderer = new import_three.WebGLRenderer({ alpha: true });
+_AssetRenderer.previewCamera = new import_webgpu.PerspectiveCamera(50, 1, 0, 10);
+_AssetRenderer.initialized = false;
+let AssetRenderer = _AssetRenderer;

package/dist/Renderer/AssetRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { Object3D } from 'three/webgpu';
+import { WebGLRenderer } from 'three';
+import { PerspectiveCamera, Scene } from 'three/webgpu';
+export default class AssetRenderer {
+    item: import("three/examples/jsm/Addons.js").GLTF | import("three").Texture | AudioBuffer | import("three/examples/jsm/Addons.js").SVGResult | import("three/examples/jsm/Addons.js").Font;
+    static previewScene: Scene;
+    static previewRenderer: WebGLRenderer;
+    static previewCamera: PerspectiveCamera;
+    static initialized: boolean;
+    constructor(key: string);
+    initRenderer(): void;
+    adjustCameraToModel(model: Object3D): void;
+    render(): string | undefined;
+}

package/dist/Renderer/AssetRenderer.js

@@ -0,0 +1,52 @@
+import { WebGLRenderer } from 'three';
+import { Box3, DirectionalLight, PerspectiveCamera, Scene, Vector3 } from 'three/webgpu';
+import Game from '../Game';
+class AssetRenderer {
+    constructor(key) {
+        this.item = Game.instance().resources.items[key];
+        this.initRenderer();
+        if ('scene' in this.item) {
+            AssetRenderer.previewScene.add(this.item.scene);
+            this.adjustCameraToModel(this.item.scene);
+        }
+    }
+    initRenderer() {
+        if (AssetRenderer.initialized)
+            return;
+        AssetRenderer.previewRenderer.setSize(100, 100);
+        const light = new DirectionalLight(0xFFFFFF, 3);
+        light.position.set(5, 5, 5);
+        AssetRenderer.previewScene.add(light);
+        const ambientLight = new DirectionalLight(0xFFFFFF, 4);
+        ambientLight.position.set(-5, -5, -5);
+        AssetRenderer.previewScene.add(ambientLight);
+        AssetRenderer.initialized = true;
+    }
+    adjustCameraToModel(model) {
+        const box = new Box3().setFromObject(model);
+        const size = new Vector3();
+        const center = new Vector3();
+        box.getSize(size);
+        box.getCenter(center);
+        const maxDim = Math.max(size.x, size.y, size.z);
+        const fov = AssetRenderer.previewCamera.fov * (Math.PI / 180);
+        const cameraZ = maxDim / (2 * Math.tan(fov / 2));
+        AssetRenderer.previewCamera.position.set(center.x, center.y, center.z + cameraZ * 1.5);
+        AssetRenderer.previewCamera.lookAt(center);
+        AssetRenderer.previewCamera.near = 0.1;
+        AssetRenderer.previewCamera.far = cameraZ + maxDim * 2;
+        AssetRenderer.previewCamera.updateProjectionMatrix();
+    }
+    render() {
+        if ('scene' in this.item === false)
+            return;
+        AssetRenderer.previewRenderer.render(AssetRenderer.previewScene, AssetRenderer.previewCamera);
+        AssetRenderer.previewScene.remove(this.item.scene);
+        return AssetRenderer.previewRenderer.domElement.toDataURL();
+    }
+}
+AssetRenderer.previewScene = new Scene();
+AssetRenderer.previewRenderer = new WebGLRenderer({ alpha: true });
+AssetRenderer.previewCamera = new PerspectiveCamera(50, 1, 0, 10);
+AssetRenderer.initialized = false;
+export default AssetRenderer;