@mavonengine/core 0.0.2

package/dist/Prefab/Primitives/index.js

@@ -0,0 +1,217 @@
+import { BoxGeometry, CapsuleGeometry, CatmullRomCurve3, CircleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, EdgesGeometry, ExtrudeGeometry, IcosahedronGeometry, LatheGeometry, LineBasicMaterial, LineSegments, Mesh, MeshStandardMaterial, OctahedronGeometry, PlaneGeometry, PolyhedronGeometry, RingGeometry, Shape, ShapeGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, TorusKnotGeometry, TubeGeometry, Vector2, Vector3, WireframeGeometry, } from 'three';
+import { WithEditorHelper } from '../../Editor/WithEditorHelper';
+import Game from '../../Game';
+import GameObject from '../../World/GameObject';
+export class Primitive extends WithEditorHelper(GameObject) {
+    constructor(position, object, label) {
+        super(undefined, position);
+        this.instance = object;
+        this.instance.position.copy(position);
+        Game.instance().scene.add(this.instance);
+        const isMeshStd = this.instance instanceof Mesh && this.instance.material instanceof MeshStandardMaterial;
+        const mat = isMeshStd ? this.instance.material : null;
+        this.registerEditorHelper(position, label, {
+            onMove: (delta) => this.instance.position.add(delta),
+            properties: mat
+                ? [
+                    { type: 'color', label: 'color', getValue: () => `#${mat.color.getHexString()}`, setValue: (v) => mat.color.set(v) },
+                    {
+                        type: 'checkbox',
+                        label: 'wireframe',
+                        getValue: () => mat.wireframe,
+                        setValue: (v) => {
+                            mat.wireframe = v;
+                            mat.needsUpdate = true;
+                        },
+                    },
+                    { type: 'slider', label: 'roughness', min: 0, max: 1, step: 0.01, getValue: () => mat.roughness, setValue: (v) => { mat.roughness = v; } },
+                    { type: 'slider', label: 'metalness', min: 0, max: 1, step: 0.01, getValue: () => mat.metalness, setValue: (v) => { mat.metalness = v; } },
+                ]
+                : [],
+        });
+        this.tagWithHelper(this.instance);
+    }
+    setReceiveShadow(value) {
+        if (this.instance instanceof Mesh) {
+            this.instance.receiveShadow = value;
+        }
+    }
+    setCastShadow(value) {
+        if (this.instance instanceof Mesh) {
+            this.instance.castShadow = value;
+        }
+    }
+    update(_delta) { }
+    destroy() {
+        const asRenderable = this.instance;
+        asRenderable.geometry?.dispose();
+        if (Array.isArray(asRenderable.material)) {
+            asRenderable.material.forEach(m => m.dispose());
+        }
+        else {
+            asRenderable.material?.dispose();
+        }
+        Game.instance().scene.remove(this.instance);
+        super.destroy();
+    }
+}
+function mesh(geometry) {
+    return new Mesh(geometry, new MeshStandardMaterial({ color: 0x888888 }));
+}
+function lines(geometry) {
+    return new LineSegments(geometry, new LineBasicMaterial({ color: 0x4A9EFF }));
+}
+export class BoxPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new BoxGeometry()), 'Box');
+    }
+}
+export class CapsulePrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new CapsuleGeometry()), 'Capsule');
+    }
+}
+export class CirclePrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new CircleGeometry()), 'Circle');
+    }
+}
+export class ConePrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new ConeGeometry()), 'Cone');
+    }
+}
+export class CylinderPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new CylinderGeometry()), 'Cylinder');
+    }
+}
+export class DodecahedronPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new DodecahedronGeometry()), 'Dodecahedron');
+    }
+}
+export class EdgesPrimitive extends Primitive {
+    constructor(position) {
+        super(position, lines(new EdgesGeometry(new BoxGeometry())), 'Edges');
+    }
+}
+export class ExtrudePrimitive extends Primitive {
+    constructor(position) {
+        const shape = new Shape();
+        shape.moveTo(0, 0);
+        shape.lineTo(0, 1);
+        shape.lineTo(1, 1);
+        shape.lineTo(1, 0);
+        shape.closePath();
+        super(position, mesh(new ExtrudeGeometry(shape, { depth: 0.5, bevelEnabled: false })), 'Extrude');
+    }
+}
+export class IcosahedronPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new IcosahedronGeometry()), 'Icosahedron');
+    }
+}
+export class LathePrimitive extends Primitive {
+    constructor(position) {
+        const points = [];
+        for (let i = 0; i <= 10; i++) {
+            points.push(new Vector2(Math.sin(i * 0.2) * 0.5 + 0.3, i * 0.1));
+        }
+        super(position, mesh(new LatheGeometry(points, 12)), 'Lathe');
+    }
+}
+export class OctahedronPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new OctahedronGeometry()), 'Octahedron');
+    }
+}
+export class PlanePrimitive extends Primitive {
+    constructor(position, width = 1, height = 1) {
+        const geometry = new PlaneGeometry(width, height);
+        geometry.rotateX(-Math.PI / 2);
+        super(position, mesh(geometry), 'Plane');
+    }
+}
+export class PolyhedronPrimitive extends Primitive {
+    constructor(position) {
+        const vertices = [1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1];
+        const indices = [2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1];
+        super(position, mesh(new PolyhedronGeometry(vertices, indices, 0.8, 2)), 'Polyhedron');
+    }
+}
+export class RingPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new RingGeometry(0.5, 1)), 'Ring');
+    }
+}
+export class ShapePrimitive extends Primitive {
+    constructor(position) {
+        const shape = new Shape();
+        shape.moveTo(0, 0);
+        shape.lineTo(0, 1);
+        shape.lineTo(1, 1);
+        shape.lineTo(1, 0);
+        shape.closePath();
+        super(position, mesh(new ShapeGeometry(shape)), 'Shape');
+    }
+}
+export class SpherePrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new SphereGeometry()), 'Sphere');
+    }
+}
+export class TetrahedronPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new TetrahedronGeometry()), 'Tetrahedron');
+    }
+}
+export class TorusPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new TorusGeometry()), 'Torus');
+    }
+}
+export class TorusKnotPrimitive extends Primitive {
+    constructor(position) {
+        super(position, mesh(new TorusKnotGeometry()), 'TorusKnot');
+    }
+}
+export class TubePrimitive extends Primitive {
+    constructor(position) {
+        const path = new CatmullRomCurve3([
+            new Vector3(-1, 0, 0),
+            new Vector3(-0.5, 0.5, 0),
+            new Vector3(0.5, -0.5, 0),
+            new Vector3(1, 0, 0),
+        ]);
+        super(position, mesh(new TubeGeometry(path, 20, 0.2, 8, false)), 'Tube');
+    }
+}
+export class WireframePrimitive extends Primitive {
+    constructor(position) {
+        super(position, lines(new WireframeGeometry(new BoxGeometry())), 'Wireframe');
+    }
+}
+export const PRIMITIVE_REGISTRY = {
+    Box: BoxPrimitive,
+    Capsule: CapsulePrimitive,
+    Circle: CirclePrimitive,
+    Cone: ConePrimitive,
+    Cylinder: CylinderPrimitive,
+    Dodecahedron: DodecahedronPrimitive,
+    Edges: EdgesPrimitive,
+    Extrude: ExtrudePrimitive,
+    Icosahedron: IcosahedronPrimitive,
+    Lathe: LathePrimitive,
+    Octahedron: OctahedronPrimitive,
+    Plane: PlanePrimitive,
+    Polyhedron: PolyhedronPrimitive,
+    Ring: RingPrimitive,
+    Shape: ShapePrimitive,
+    Sphere: SpherePrimitive,
+    Tetrahedron: TetrahedronPrimitive,
+    Torus: TorusPrimitive,
+    TorusKnot: TorusKnotPrimitive,
+    Tube: TubePrimitive,
+    Wireframe: WireframePrimitive,
+};

package/dist/Prefab/Water/Fragment.glsl

@@ -0,0 +1,36 @@
+uniform vec3 uDepthColor;
+uniform vec3 uSurfaceColor;
+uniform float uColorOffset;
+uniform float uColorMultiplier;
+
+uniform vec3 uSunDirection;
+uniform float uSunReflectionStrength;
+
+varying float vElevation;
+varying vec3 vWorldPosition;
+
+void main()
+{
+    float mixStrength = (vElevation + uColorOffset) * uColorMultiplier;
+
+    vec3 color = mix(uDepthColor, uSurfaceColor, mixStrength);
+
+    // Sun reflection
+    vec3 normal = normalize(cross(dFdx(vWorldPosition), dFdy(vWorldPosition)));
+    vec3 viewDir = normalize(cameraPosition - vWorldPosition);
+    vec3 sunDir = normalize(uSunDirection);
+
+    // Specular highlight (Blinn-Phong)
+    vec3 halfDir = normalize(sunDir + viewDir);
+    float spec = pow(max(dot(normal, halfDir), 0.0), 128.0);
+
+    // Fresnel - stronger reflections at grazing angles
+    float fresnel = pow(1.0 - max(dot(normal, viewDir), 0.0), 3.0);
+
+    vec3 sunColor = vec3(1.0, 0.95, 0.8);
+    color += sunColor * spec * (0.5 + fresnel * 0.5) * uSunReflectionStrength;
+
+    gl_FragColor = vec4(color, 0.9);
+
+    #include <colorspace_fragment>
+}

package/dist/Prefab/Water/Vertex.glsl

@@ -0,0 +1,60 @@
+uniform float uBigWavesElevation;
+uniform vec2 uBigWavesFrequency;
+uniform float uBigWavesSpeed;
+
+uniform float uTime;
+
+uniform vec3 uSurfaceColor;
+uniform vec3 uDepthColor;
+
+#define MAX_PUSH_POINTS 150
+
+uniform vec3 pushPositions[MAX_PUSH_POINTS];
+uniform float pushRadii[MAX_PUSH_POINTS];
+
+varying float vElevation;
+varying vec3 vWorldPosition;
+
+#include ../../Shaders/Vertex/ClassicPerlin3DNoise;
+
+float computeRipple(vec3 worldPos) {
+    float totalRipple = 0.0;
+
+    for (int i = 0; i < MAX_PUSH_POINTS; i++) {
+        float dist = distance(worldPos.xz, pushPositions[i].xz);
+        float influence = smoothstep(pushRadii[i], 0.0, dist);
+
+        // Expanding ring ripple pattern
+        float ripple = sin(dist * 8.0 - uTime * 4.0) * influence;
+        totalRipple += ripple;
+    }
+
+    return totalRipple;
+}
+
+void main()
+{
+    vec4 modelPosition = modelMatrix * vec4(position, 1.0);
+
+    float elevation = sin(modelPosition.x * uBigWavesFrequency.x + uTime * uBigWavesSpeed) *
+                      sin(modelPosition.z * uBigWavesFrequency.y + uTime * uBigWavesSpeed) *
+                      uBigWavesElevation;
+
+    for (float i = 1.0; i <= 4.0; i++){
+        elevation -= abs(cnoise(vec3(modelPosition.xz * 3.0 * i, uTime * 0.2)) * 0.15 / i);
+    }
+
+    // Player ripples
+    elevation += computeRipple(modelPosition.xyz) * 0.2;
+
+    modelPosition.y += elevation;
+
+    vec4 viewPosition = viewMatrix * modelPosition;
+    vec4 projectedPosition = projectionMatrix * viewPosition;
+
+    gl_Position = projectedPosition;
+
+    // Varyings
+    vElevation = elevation;
+    vWorldPosition = modelPosition.xyz;
+}

package/dist/Prefab/Water/Water.cjs

@@ -0,0 +1,234 @@
+"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 Water_exports = {};
+__export(Water_exports, {
+  default: () => Water
+});
+module.exports = __toCommonJS(Water_exports);
+var import_WithEditorHelper = require("../../Editor/WithEditorHelper");
+var import_Game = __toESM(require("../../Game"), 1);
+var import_GameObject = __toESM(require("../../World/GameObject"), 1);
+var import_three = require("three");
+var import_Fragment = __toESM(require("./Fragment.glsl"), 1);
+var import_Vertex = __toESM(require("./Vertex.glsl"), 1);
+var import_WaterManager = __toESM(require("./WaterManager"), 1);
+const MAX_PUSH_POINTS = 150;
+const DEFAULT_LOD = {
+  segments: [512, 128, 32],
+  distances: [40, 60]
+};
+class Water extends (0, import_WithEditorHelper.WithEditorHelper)(import_GameObject.default) {
+  constructor(position, size, sectionCount = 1, lod = DEFAULT_LOD) {
+    super(void 0, position);
+    this.sections = [];
+    this.cullPadding = 0;
+    this.lodConfig = lod;
+    this.sectionCount = sectionCount;
+    this.material = new import_three.ShaderMaterial({
+      transparent: true,
+      stencilWrite: true,
+      stencilFunc: import_three.EqualStencilFunc,
+      stencilRef: 0,
+      stencilZPass: import_three.IncrementStencilOp,
+      fragmentShader: import_Fragment.default,
+      vertexShader: import_Vertex.default,
+      uniforms: {
+        uTime: { value: 0 },
+        uBigWavesElevation: { value: 0.38 },
+        uBigWavesFrequency: { value: new import_three.Vector2(0.326, 0.978) },
+        uBigWavesSpeed: { value: 1 },
+        uDepthColor: { value: new import_three.Color("#186691") },
+        uSurfaceColor: { value: new import_three.Color("#9bd8ff") },
+        uColorOffset: { value: 0.38 },
+        uColorMultiplier: { value: 0.761 },
+        pushPositions: {
+          value: Array.from({ length: MAX_PUSH_POINTS }, () => new import_three.Vector3())
+        },
+        pushRadii: {
+          value: Array.from({ length: MAX_PUSH_POINTS }).fill(0)
+        },
+        uSunDirection: { value: new import_three.Vector3(0, 1, 0) },
+        uSunReflectionStrength: { value: 1 }
+      }
+    });
+    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 import_three.PlaneGeometry(geoSize, geoSize, farSegments, farSegments);
+        const mesh = new import_three.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 });
+        import_Game.default.instance().scene.add(mesh);
+      }
+    }
+    this.registerEditorHelper(position, "Water", {
+      addBindings: (folder) => import_WaterManager.default.instance?.addBindings(folder)
+    });
+    for (const section of this.sections)
+      this.tagWithHelper(section.mesh);
+    this.addDebugTools();
+  }
+  addDebugTools() {
+    if (!import_Game.default.instance().debug.active || !import_WaterManager.default.instance)
+      return;
+    import_WaterManager.default.instance.uBigWavesElevationController?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesElevation.value = ev.value;
+    });
+    import_WaterManager.default.instance.uBigWavesFrequencyControllerX?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesFrequency.value.setX(ev.value);
+    });
+    import_WaterManager.default.instance.uBigWavesFrequencyControllerY?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesFrequency.value.setY(ev.value);
+    });
+    import_WaterManager.default.instance.uBigWavesSpeedController?.on("change", (ev) => {
+      this.material.uniforms.uBigWavesSpeed.value = ev.value;
+    });
+    import_WaterManager.default.instance.uDepthColorController?.on("change", (ev) => {
+      this.material.uniforms.uDepthColor.value = new import_three.Color(ev.value);
+    });
+    import_WaterManager.default.instance.uSurfaceColorController?.on("change", (ev) => {
+      this.material.uniforms.uSurfaceColor.value = new import_three.Color(ev.value);
+    });
+    import_WaterManager.default.instance.uColorOffsetController?.on("change", (ev) => {
+      this.material.uniforms.uColorOffset.value = ev.value;
+    });
+    import_WaterManager.default.instance.uColorMultiplierController?.on("change", (ev) => {
+      this.material.uniforms.uColorMultiplier.value = ev.value;
+    });
+    import_WaterManager.default.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 import_three.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 = import_Game.default.instance().clock.elapsedTime;
+    if (import_WaterManager.default.instance) {
+      this.material.uniforms.uSunDirection.value.copy(import_WaterManager.default.instance.sunPosition);
+    }
+    const cameraPos = import_Game.default.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();
+      import_Game.default.instance().scene.remove(section.mesh);
+    }
+    this.material.dispose();
+    super.destroy();
+  }
+}

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

@@ -0,0 +1,41 @@
+import type { Vector3 } from 'three';
+import GameObject from '../../World/GameObject';
+import { ShaderMaterial } from 'three';
+export interface WaterLODConfig {
+    segments: [close: number, medium: number, far: number];
+    distances: [closeToMedium: number, mediumToFar: number];
+}
+declare const Water_base: (abstract new (...args: any[]) => {
+    editorHelper: import("../../Editor/EditorHelper").default | undefined;
+    registerEditorHelper(position: Vector3, label: string, attachment?: import("../../Editor/EditorHelper").EditorHelperAttachment | null): void;
+    tagWithHelper(mesh: import("three").Object3D): void;
+    destroy(): void;
+}) & typeof GameObject;
+/**
+ * https://threejs-journey.com/lessons/raging-sea
+ */
+export default class Water extends Water_base {
+    material: ShaderMaterial;
+    private sections;
+    private lodConfig;
+    private sectionCount;
+    private cullHeight?;
+    private cullPadding;
+    constructor(position: Vector3, size: number, sectionCount?: number, lod?: WaterLODConfig);
+    private addDebugTools;
+    private swapGeometry;
+    private cullGeometry;
+    /**
+     * 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: (worldX: number, worldZ: number) => number, padding?: number): void;
+    setPushPoints(points: {
+        position: Vector3;
+        radius: number;
+    }[]): void;
+    update(_delta: number): void;
+    destroy(): void;
+}
+export {};