diamon-engine 0.1.0

package/dist/package/engine3d.js

@@ -0,0 +1,14 @@
+import { C as t, E as n, L as s, M as o, O as r, a as D, S as i } from "./OrbitCameraController-COklTntj.js";
+import { E as p, I as C, S as E } from "./Spin3D-BW0UYD9X.js";
+export {
+  t as Component3D,
+  p as Engine3D,
+  n as Entity3D,
+  C as Input3D,
+  s as Light3D,
+  o as MeshPrimitive3D,
+  r as Object3DComponent,
+  D as OrbitCameraController,
+  i as Scene3D,
+  E as Spin3D
+};

package/dist/package/index.js

@@ -0,0 +1,14 @@
+import { C as t, E as n, L as s, M as o, O as r, a as D, S as i } from "./OrbitCameraController-COklTntj.js";
+import { E as p, I as C, S as E } from "./Spin3D-BW0UYD9X.js";
+export {
+  t as Component3D,
+  p as Engine3D,
+  n as Entity3D,
+  C as Input3D,
+  s as Light3D,
+  o as MeshPrimitive3D,
+  r as Object3DComponent,
+  D as OrbitCameraController,
+  i as Scene3D,
+  E as Spin3D
+};

package/dist/package/types/engine3d/components/Light3D.d.ts

@@ -0,0 +1,16 @@
+import { Component3D } from "../core/Component3D";
+export type Light3DKind = "ambient" | "directional" | "point";
+export interface Light3DOptions {
+    kind: Light3DKind;
+    color?: string;
+    intensity?: number;
+    castShadow?: boolean;
+}
+export declare class Light3D extends Component3D {
+    private readonly options;
+    updatesEveryFrame: boolean;
+    private light?;
+    constructor(options: Light3DOptions);
+    onStart(): void;
+    onDestroy(): void;
+}

package/dist/package/types/engine3d/components/MeshPrimitive3D.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from "three";
+import { Component3D } from "../core/Component3D";
+export type MeshPrimitiveKind = "box" | "sphere" | "cylinder" | "cone" | "torus" | "plane";
+export interface MeshPrimitive3DOptions {
+    kind: MeshPrimitiveKind;
+    color?: string;
+    width?: number;
+    height?: number;
+    depth?: number;
+    radius?: number;
+    radiusTop?: number;
+    radiusBottom?: number;
+    tube?: number;
+    segments?: number;
+    metalness?: number;
+    roughness?: number;
+    receiveShadow?: boolean;
+    castShadow?: boolean;
+    sharedResources?: boolean;
+}
+export declare class MeshPrimitive3D extends Component3D {
+    readonly options: MeshPrimitive3DOptions;
+    updatesEveryFrame: boolean;
+    mesh?: THREE.Mesh;
+    private geometry?;
+    private material?;
+    private geometryCacheKey;
+    private materialCacheKey;
+    constructor(options: MeshPrimitive3DOptions);
+    onStart(): void;
+    onDestroy(): void;
+    setColor(color: string): void;
+    getColor(): string;
+    private createGeometry;
+    private acquireGeometry;
+    private acquireMaterial;
+    private releaseGeometry;
+    private releaseMaterial;
+    private createMaterial;
+    private getGeometryKey;
+    private getMaterialKey;
+    private usesSharedResources;
+}

package/dist/package/types/engine3d/components/Object3DComponent.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { Component3D } from "../core/Component3D";
+export interface Object3DComponentOptions {
+    disposeOnDestroy?: boolean;
+}
+export declare class Object3DComponent extends Component3D {
+    object: THREE.Object3D;
+    private readonly options;
+    updatesEveryFrame: boolean;
+    constructor(object: THREE.Object3D, options?: Object3DComponentOptions);
+    onStart(): void;
+    onDestroy(): void;
+    replaceObject(object: THREE.Object3D): void;
+}

package/dist/package/types/engine3d/components/OrbitCameraController.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from "three";
+import { Component3D } from "../core/Component3D";
+export interface OrbitCameraControllerOptions {
+    target?: THREE.Vector3;
+    distance?: number;
+    minDistance?: number;
+    maxDistance?: number;
+    azimuth?: number;
+    polar?: number;
+}
+export declare class OrbitCameraController extends Component3D {
+    target: THREE.Vector3;
+    distance: number;
+    minDistance: number;
+    maxDistance: number;
+    azimuth: number;
+    polar: number;
+    constructor(options?: OrbitCameraControllerOptions);
+    onUpdate(): void;
+}

package/dist/package/types/engine3d/components/Spin3D.d.ts

@@ -0,0 +1,8 @@
+import { Component3D } from "../core/Component3D";
+export declare class Spin3D extends Component3D {
+    private readonly x;
+    private readonly y;
+    private readonly z;
+    constructor(x?: number, y?: number, z?: number);
+    onUpdate(deltaTime: number): void;
+}

package/dist/package/types/engine3d/core/Component3D.d.ts

@@ -0,0 +1,17 @@
+import type { Engine3D } from "./Engine3D";
+import type { Entity3D } from "./Entity3D";
+import type { Scene3D } from "./Scene3D";
+export declare abstract class Component3D {
+    entity: Entity3D;
+    enabled: boolean;
+    updatesEveryFrame: boolean;
+    private started;
+    get scene(): Scene3D | undefined;
+    get engine(): Engine3D | undefined;
+    startInternal(): void;
+    updateInternal(deltaTime: number): void;
+    destroyInternal(): void;
+    onStart(): void;
+    onUpdate(_deltaTime: number): void;
+    onDestroy(): void;
+}

package/dist/package/types/engine3d/core/Engine3D.d.ts

@@ -0,0 +1,65 @@
+import * as THREE from "three";
+import type { Scene3D } from "./Scene3D";
+import { Input3D } from "../systems/Input3D";
+export interface Engine3DStats {
+    fps: number;
+    frameTimeMs: number;
+    frameTimeAverageMs: number;
+    width: number;
+    height: number;
+    entities: number;
+    updatableEntities: number;
+    drawCalls: number;
+    triangles: number;
+    geometries: number;
+    textures: number;
+    pixelRatio: number;
+    qualityScale: number;
+}
+export type Engine3DShadowQuality = "off" | "low" | "medium" | "high";
+export interface Engine3DOptions {
+    canvas: HTMLCanvasElement;
+    background?: string;
+    maxPixelRatio?: number;
+    minPixelRatio?: number;
+    preserveDrawingBuffer?: boolean;
+    shadowQuality?: Engine3DShadowQuality;
+    targetFps?: number;
+}
+export declare class Engine3D {
+    private readonly options;
+    readonly renderer: THREE.WebGLRenderer;
+    readonly input: Input3D;
+    readonly stats: Engine3DStats;
+    activeScene?: Scene3D;
+    private running;
+    private animationFrame;
+    private lastTimestamp;
+    private fpsElapsed;
+    private fpsFrames;
+    private qualityScale;
+    private frameTimeAverageMs;
+    private lastResizeWidth;
+    private lastResizeHeight;
+    private lastPixelRatio;
+    private resizeDirty;
+    private slowQualitySamples;
+    private fastQualitySamples;
+    constructor(options: Engine3DOptions);
+    setScene(scene: Scene3D): void;
+    start(): void;
+    stop(): void;
+    renderOnce(): void;
+    sampleFrame(): {
+        width: number;
+        height: number;
+        coloredRatio: number;
+    };
+    private readonly tick;
+    private resize;
+    private updateFrameTimeAverage;
+    private updateFps;
+    private updateRenderStats;
+    private adjustQualityScale;
+    private configureShadows;
+}

package/dist/package/types/engine3d/core/Entity3D.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from "three";
+import { Component3D } from "./Component3D";
+import type { Scene3D } from "./Scene3D";
+type ComponentConstructor<T extends Component3D> = new (...args: never[]) => T;
+export declare class Entity3D {
+    name: string;
+    readonly id: number;
+    readonly object: THREE.Group<THREE.Object3DEventMap>;
+    readonly components: Component3D[];
+    private readonly frameUpdateComponents;
+    scene?: Scene3D;
+    tag: string;
+    enabled: boolean;
+    destroyed: boolean;
+    constructor(name?: string);
+    get position(): THREE.Vector3;
+    get rotation(): THREE.Euler;
+    get scale(): THREE.Vector3;
+    addComponent<T extends Component3D>(component: T): T;
+    getComponent<T extends Component3D>(componentType: ComponentConstructor<T>): T | undefined;
+    destroy(): void;
+    get needsFrameUpdate(): boolean;
+    startInternal(): void;
+    updateInternal(deltaTime: number): void;
+    destroyInternal(): void;
+}
+export {};

package/dist/package/types/engine3d/core/Scene3D.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from "three";
+import { Entity3D } from "./Entity3D";
+import type { Engine3D } from "./Engine3D";
+export declare class Scene3D {
+    name: string;
+    readonly threeScene: THREE.Scene<THREE.Object3DEventMap>;
+    readonly camera: THREE.PerspectiveCamera;
+    readonly entities: Entity3D[];
+    private readonly frameUpdateEntities;
+    private destroyedEntityCount;
+    engine?: Engine3D;
+    isStarted: boolean;
+    constructor(name?: string);
+    add(entity: Entity3D): Entity3D;
+    remove(entity: Entity3D): void;
+    findByTag(tag: string): Entity3D[];
+    get updatableEntityCount(): number;
+    refreshEntityScheduling(entity: Entity3D): void;
+    markEntityDestroyed(entity: Entity3D): void;
+    startInternal(engine: Engine3D): void;
+    updateInternal(deltaTime: number): void;
+    stopInternal(): void;
+    onStart(): void;
+    onUpdate(_deltaTime: number): void;
+    onStop(): void;
+    private removeDestroyedEntities;
+}

package/dist/package/types/engine3d/index.d.ts

@@ -0,0 +1,10 @@
+export { Component3D } from "./core/Component3D";
+export { Engine3D, type Engine3DStats } from "./core/Engine3D";
+export { Entity3D } from "./core/Entity3D";
+export { Scene3D } from "./core/Scene3D";
+export { Input3D } from "./systems/Input3D";
+export { Light3D } from "./components/Light3D";
+export { MeshPrimitive3D, type MeshPrimitive3DOptions } from "./components/MeshPrimitive3D";
+export { Object3DComponent } from "./components/Object3DComponent";
+export { OrbitCameraController } from "./components/OrbitCameraController";
+export { Spin3D } from "./components/Spin3D";

package/dist/package/types/engine3d/systems/Input3D.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+export declare class Input3D {
+    private readonly canvas;
+    readonly pointer: THREE.Vector2;
+    readonly pointerDelta: THREE.Vector2;
+    wheelDelta: number;
+    private readonly downKeys;
+    private readonly pressedKeys;
+    private readonly releasedKeys;
+    private readonly downButtons;
+    private readonly pressedButtons;
+    private readonly releasedButtons;
+    constructor(canvas: HTMLCanvasElement);
+    isKeyDown(key: string): boolean;
+    wasKeyPressed(key: string): boolean;
+    isAnyKeyDown(keys: string[]): boolean;
+    isMouseDown(button?: number): boolean;
+    wasMousePressed(button?: number): boolean;
+    endFrame(): void;
+    private readonly handleKeyDown;
+    private readonly handleKeyUp;
+    private readonly handlePointerMove;
+    private readonly handlePointerDown;
+    private readonly handlePointerUp;
+    private readonly handleWheel;
+    private pointerToCanvas;
+    private getKeyAliases;
+    private normalizeKey;
+}

package/dist/package/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./engine3d";

package/dist/package/types/workbench/createEngineWorkbench.d.ts

@@ -0,0 +1,56 @@
+import { Entity3D, Scene3D } from "../engine3d";
+export type WorkbenchPrimitiveKind = "box" | "sphere" | "cylinder" | "cone" | "torus";
+interface WorkbenchUi {
+    objects: HTMLElement;
+    visible: HTMLElement;
+    drawCalls: HTMLElement;
+    triangles: HTMLElement;
+    fps: HTMLElement;
+    frame: HTMLElement;
+    geometries: HTMLElement;
+    textures: HTMLElement;
+    assets: HTMLElement;
+    memory: HTMLElement;
+    quality: HTMLElement;
+    slowSystem: HTMLElement;
+    state: HTMLElement;
+    selected: HTMLElement;
+    sceneTree: HTMLElement;
+    resourceList: HTMLElement;
+    prefabList: HTMLElement;
+    propertyPanel: HTMLElement;
+    sceneData: HTMLTextAreaElement;
+    logList: HTMLElement;
+}
+export interface EngineWorkbench {
+    scene: Scene3D;
+    addPrimitive: (kind: WorkbenchPrimitiveKind) => Entity3D;
+    copySelection: () => void;
+    pasteSelection: () => void;
+    deleteSelection: () => void;
+    undo: () => void;
+    redo: () => void;
+    selectAll: () => void;
+    createGroupFromSelection: () => void;
+    saveScene: () => void;
+    loadScene: () => void;
+    downloadScene: () => void;
+    createPrefabFromSelection: () => void;
+    addStressObjects: (count: number) => void;
+    addInstancedStressObjects: (count: number) => void;
+    addMegaInstancedStressObjects: (count: number) => void;
+    setMegaInstancedStressObjects: (count: number) => void;
+    importAssets: (files: FileList | File[]) => void;
+    clearLogs: () => void;
+    stats: () => WorkbenchDebugStats;
+}
+interface WorkbenchDebugStats {
+    objects: number;
+    logicalObjects: number;
+    resources: number;
+    prefabs: number;
+    selected: number;
+    lastStressResult: string;
+}
+export declare function createEngineWorkbench(ui: WorkbenchUi): EngineWorkbench;
+export {};

package/dist/package/types/workbench/index.d.ts

@@ -0,0 +1 @@
+export { createEngineWorkbench, type EngineWorkbench, type WorkbenchPrimitiveKind } from "./createEngineWorkbench";