@woosh/meep-engine 2.39.16 → 2.39.19

package/core/color/Color.js

@@ -12,6 +12,8 @@ import { clamp01 } from "../math/clamp01.js";
 import { rgb2hex } from "./rgb2hex.js";
 import { linear_to_sRGB } from "./linear_to_sRGB.js";
 import { sRGB_to_linear } from "./sRGB_to_linear.js";
+import { lerp } from "../math/lerp.js";
+import { float2uint8 } from "../binary/float2uint8.js";
 
 /**
  * @class
@@ -22,8 +24,9 @@ export class Color {
      * @param {number} r value from 0 to 1
      * @param {number} g value from 0 to 1
      * @param {number} b value from 0 to 1
+     * @param {number} [a] value from 0 to 1
      */
-    constructor(r = 0, g = 0, b = 0) {
+    constructor(r = 0, g = 0, b = 0, a = 1) {
         /**
          * Red channel
          * Value from 0 to 1
@@ -43,6 +46,13 @@ export class Color {
          */
         this.b = b;
 
+        /**
+         * Alpha channel
+         * Value from 0 to 1
+         * @type {number}
+         */
+        this.a = a;
+
         /**
          * @readonly
          * @type {Signal<number,number,number,number,number,number>}
@@ -98,6 +108,22 @@ export class Color {
         this.b = v;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    get 3() {
+        return this.a;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set 3(v) {
+        this.a = v;
+    }
+
     /**
      *
      * @param {number} r
@@ -356,12 +382,20 @@ export class Color {
      */
     toHex() {
         return '#' + rgb2hex(
-            Math.round(this.r),
-            Math.round(this.g),
-            Math.round(this.b)
+            float2uint8(this.r),
+            float2uint8(this.g),
+            float2uint8(this.b)
         );
     }
 
+    /**
+     *
+     * @returns {string}
+     */
+    toCssRGBAString() {
+        return `rgba(${float2uint8(this.r)},${float2uint8(this.g)},${float2uint8(this.b)},${this.a})`;
+    }
+
     /**
      *
      * @param {Color} other
@@ -463,9 +497,28 @@ export class Color {
     parse(str) {
         const c = parseColor(str);
 
+        if (typeof c[3] === "number") {
+            this.a = c[3];
+        } else {
+            this.a = 1;
+        }
+
         this.setRGB(c[0] / 255, c[1] / 255, c[2] / 255);
     }
 
+    /**
+     *
+     * @param {Color} a
+     * @param {Color} b
+     * @param {number} f
+     */
+    lerpColors(a, b, f) {
+        this.r = lerp(a.r, b.r, f);
+        this.g = lerp(a.g, b.g, f);
+        this.b = lerp(a.b, b.b, f);
+        this.a = lerp(a.a, b.a, f);
+    }
+
     /**
      *
      * @param {number} r
@@ -557,3 +610,9 @@ Color.white = Object.freeze(new Color(1, 1, 1));
  * @type {Readonly<Color>}
  */
 Color.black = Object.freeze(new Color(0, 0, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.transparent = Object.freeze(new Color(0, 0, 0, 0));

package/core/color/ColorUtils.js

@@ -6,7 +6,8 @@ import { hsv2rgb } from "./hsv2rgb.js";
 import { parseHex } from "./parseHex.js";
 
 
-const rgbRegEx = /rgb\(([0-9]+),\s*([0-9]+),\s*([0-9]+)\)/;
+const rgbRegEx = /rgb\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\s*\)/;
+const rgbaRegEx = /rgba\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+),\s*([0-9]+(?:\.[0-9]*)?)\s*\)/;
 const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
 
 /**
@@ -20,6 +21,8 @@ export function parseColor(c) {
 
     const type_of_code = typeof c;
 
+    let r, g, b, a = 1;
+
     if (type_of_code === "string") {
         const cL = c.toLowerCase();
 
@@ -27,9 +30,16 @@ export function parseColor(c) {
 
         if ((match = cL.match(rgbRegEx)) !== null) {
 
-            result[0] = parseInt(match[1]);
-            result[1] = parseInt(match[2]);
-            result[2] = parseInt(match[3]);
+            r = parseInt(match[1]);
+            g = parseInt(match[2]);
+            b = parseInt(match[3]);
+
+        } else if ((match = cL.match(rgbaRegEx)) !== null) {
+
+            r = parseInt(match[1]);
+            g = parseInt(match[2]);
+            b = parseInt(match[3]);
+            a = parseInt(match[4]);
 
         } else if ((match = cL.match(hsvRegEx)) !== null) {
 
@@ -39,31 +49,37 @@ export function parseColor(c) {
                 parseFloat(match[3])
             );
 
-            result[0] = rgb.r;
-            result[1] = rgb.g;
-            result[2] = rgb.b;
+            r = rgb.r;
+            g = rgb.g;
+            b = rgb.b;
 
         } else if (cL.startsWith('#')) {
 
             const rgb = parseHex(cL);
 
-            result[0] = rgb.r;
-            result[1] = rgb.g;
-            result[2] = rgb.b;
+            r = rgb.r;
+            g = rgb.g;
+            b = rgb.b;
 
         } else {
             throw new Error(`Failed to decode color string '${c}' `);
         }
     } else if (type_of_code === 'number') {
 
-        result[0] = c >> 16;
-        result[1] = (c >> 8) & 0xFF;
-        result[2] = (c) & 0xFF;
+        r = c >> 16;
+        g = (c >> 8) & 0xFF;
+        b = (c) & 0xFF;
 
     } else {
         throw new Error(`Failed to decode color '${c}'`);
     }
 
+    result[0] = r;
+    result[1] = g;
+    result[2] = b;
+    result[3] = a;
+
+
     return result;
 }
 

package/core/function/Functions.js

@@ -52,6 +52,15 @@ export function returnEmptyArray() {
     return [];
 }
 
+/**
+ * @template T
+ * @param {T} v
+ * @returns {function():T}
+ */
+export function makeReturnValue(v) {
+    return () => v;
+}
+
 /**
  * @template A
  * @param {A} a

package/core/geom/Vector3.js

@@ -1000,6 +1000,13 @@ Vector3.zero = Object.freeze(new Vector3(0, 0, 0));
  */
 Vector3.one = Object.freeze(new Vector3(1, 1, 1));
 
+/**
+ * Useful for setting scale
+ * @readonly
+ * @type {Vector3}
+ */
+Vector3.minus_one = Object.freeze(new Vector3(-1, -1, -1));
+
 /**
  * @readonly
  * @type {Vector3}

package/editor/tools/paint/prototypeTerrainEditor.js

@@ -12,6 +12,10 @@ import '../../../../../../css/editor/EditorView.scss';
 import { TerrainLayer } from "../../../engine/ecs/terrain/ecs/layers/TerrainLayer.js";
 import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { BlenderCameraOrientationGizmo } from "../v2/BlenderCameraOrientationGizmo.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import { Transform } from "../../../engine/ecs/transform/Transform.js";
+import TopDownCameraController from "../../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
 
 new EngineHarness()
     .initialize({
@@ -23,17 +27,23 @@ new EngineHarness()
         }
     }).then(main);
 
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
 async function main(engine) {
     await EngineHarness.buildBasics({
         engine,
-        focus:new Vector3(128,0,128),
-        distance:30,
+        focus: new Vector3(128, 0, 128),
+        distance: 30,
         terrainResolution: 1,
         terrainSize: new Vector2(128, 128),
         enableWater: false
     });
 
-    const terrain_entity = engine.entityManager.dataset.getAnyComponent(Terrain);
+    const ecd = engine.entityManager.dataset;
+    const terrain_entity = ecd.getAnyComponent(Terrain);
     const terrain = terrain_entity.component;
 
     terrain.samplerHeight.resize(256, 256);
@@ -59,8 +69,67 @@ async function main(engine) {
 
     editor_controls.enable();
 
+    const camera_orientation_gizmo = new BlenderCameraOrientationGizmo(new Quaternion());
+
+    camera_orientation_gizmo.css({
+        position: 'absolute',
+        top: 0,
+        right: 0,
+        pointerEvents: 'auto'
+    });
+
+
+    camera_orientation_gizmo.on.axisSelected.add((axis) => {
+        /**
+         *
+         * @type {TopDownCameraController}
+         */
+        const tdcc = editor_controls.editor.cameraEntity.getComponent(TopDownCameraController);
+
+        tdcc.pitch = 0;
+        tdcc.yaw = 0;
+        tdcc.roll = 0;
+
+        switch (axis) {
+            case 'x':
+                tdcc.yaw = Math.PI / 2;
+                break;
+            case '-x':
+                tdcc.yaw = -Math.PI / 2;
+                break;
+            case 'z':
+                tdcc.yaw = 0;
+                break;
+            case '-z':
+                tdcc.yaw = Math.PI;
+                break;
+            case 'y':
+                tdcc.pitch = Math.PI / 2;
+                break;
+            case '-y':
+                tdcc.pitch = -Math.PI / 2;
+                break;
+        }
+    });
+
+    engine.gameView.addChild(camera_orientation_gizmo);
+
+    engine.graphics.on.preRender.add(() => {
+        const camera_transform = editor_controls.editor.cameraEntity.getComponent(Transform);
+
+        if (camera_transform === null) {
+            return;
+        }
+
+        camera_orientation_gizmo.orientation = camera_transform.rotation;
+
+        camera_orientation_gizmo.update();
+    });
+
     setTimeout(() => {
         editor_controls.editor.selection.add(terrain_entity.entity);
+
+        // camera_orientation_gizmo.orientation =;
     }, 100);
 
     console.warn(terrain);

package/editor/tools/v2/BlenderCameraOrientationGizmo.d.ts

@@ -0,0 +1,17 @@
+import View, {IViewSignals} from "../../../view/View";
+import Quaternion from "../../../core/geom/Quaternion";
+import Signal from "../../../core/events/signal/Signal";
+
+interface ISignals extends IViewSignals {
+    readonly axisSelected: Signal
+}
+
+export class BlenderCameraOrientationGizmo extends View {
+    constructor(orientation?: Quaternion)
+
+    on: ISignals
+
+    orientation: Quaternion | null
+
+    update(): void
+}