@woosh/meep-engine 2.37.19 → 2.37.20

package/editor/tools/paint/TerrainHeightPaintTool.js

@@ -7,9 +7,84 @@ import { QuadTreeNode } from "../../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import TransformModifyAction from "../../actions/concrete/TransformModifyAction.js";
 import EditorEntity from "../../ecs/EditorEntity.js";
+import { uint82float } from "../../../core/binary/uint82float.js";
 
 const LIMIT_VALUE = 1000;
 
+/**
+ *
+ * @param {Terrain} terrain
+ * @param {number} uv_x0
+ * @param {number} uv_y0
+ * @param {number} uv_x1
+ * @param {number} uv_y1
+ * @param {Sampler2D} marker
+ * @param {number} value_delta
+ * @param {number} limitMin
+ * @param {number} limitMax
+ * @returns {PatchTerrainHeightAction}
+ */
+function make_mod_action(terrain, uv_x0, uv_y0, uv_x1, uv_y1, marker, value_delta, limitMin, limitMax) {
+
+    const heightMap = terrain.samplerHeight;
+
+    const h_x0 = uv_x0 * heightMap.width;
+    const h_x1 = uv_x1 * heightMap.width;
+
+    const h_y0 = uv_y0 * heightMap.height;
+    const h_y1 = uv_y1 * heightMap.height;
+
+    const x0 = Math.ceil(h_x0);
+    const x1 = Math.floor(h_x1);
+
+    const y0 = Math.ceil(h_y0);
+    const y1 = Math.floor(h_y1);
+
+    const action = new PatchTerrainHeightAction(terrain, x0, y0, (x1 - x0), (y1 - y0));
+
+    const patch_destination_data = action.patch.data;
+
+    for (let y = y0; y < y1; y++) {
+
+        const v = inverseLerp(h_y0, h_y1 - 1, y);
+
+
+        for (let x = x0; x < x1; x++) {
+
+            const u = inverseLerp(h_x0, h_x1 - 1, x);
+
+            //Get alpha
+            const markerValue = marker.sampleChannelBilinearUV(u, v, 3);
+
+            const marker_value_normalized = uint82float(markerValue);
+
+            const source_address = y * heightMap.width + x;
+
+            const base = heightMap.data[source_address];
+
+            const patchAddress = (y - y0) * action.patch.width + (x - x0);
+
+            const targetValue = clamp(base + value_delta, limitMin, limitMax);
+
+
+            const value = lerp(base, targetValue, marker_value_normalized);
+
+            if (Number.isNaN(value)) {
+                // console.warn('.');
+
+                patch_destination_data[patchAddress] = base;
+
+            } else {
+
+                patch_destination_data[patchAddress] = value;
+
+            }
+        }
+
+    }
+    return action;
+}
+
 export class TerrainHeightPaintTool extends TerrainPaintTool {
 
     constructor() {
@@ -57,7 +132,7 @@ export class TerrainHeightPaintTool extends TerrainPaintTool {
         const vS = 1 / (this.terrain.size.y * gridScale);
 
         dataset.traverseComponents(Transform, (transform, entity) => {
-            if(dataset.getComponent(entity, EditorEntity) !== undefined){
+            if (dataset.getComponent(entity, EditorEntity) !== undefined) {
                 //it's an editor entity
                 return;
             }
@@ -91,7 +166,7 @@ export class TerrainHeightPaintTool extends TerrainPaintTool {
      *
      * @param {number} timeDelta
      */
-    paint(timeDelta) {
+    async paint(timeDelta) {
         const power = this.settings.brushStrength * timeDelta;
 
         /**
@@ -100,12 +175,6 @@ export class TerrainHeightPaintTool extends TerrainPaintTool {
          */
         const terrain = this.terrain;
 
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        const heightMap = terrain.samplerHeight;
-
         const brushPosition = this.__brushPosition;
         const brushSize = this.settings.brushSize;
 
@@ -123,74 +192,17 @@ export class TerrainHeightPaintTool extends TerrainPaintTool {
         const uv_y0 = uv_y - uv_h / 2;
         const uv_y1 = uv_y + uv_h / 2;
 
-        const h_x0 = uv_x0 * heightMap.width;
-        const h_x1 = uv_x1 * heightMap.width;
-
-        const h_y0 = uv_y0 * heightMap.height;
-        const h_y1 = uv_y1 * heightMap.height;
-
-        const x0 = Math.ceil(h_x0);
-        const x1 = Math.floor(h_x1);
-
-        const y0 = Math.ceil(h_y0);
-        const y1 = Math.floor(h_y1);
 
         const marker = this.settings.marker;
 
         const direction = this.modifiers.shift ? -1 : 1;
 
-        const speed = power * direction;
-
-        const action = new PatchTerrainHeightAction(terrain, x0, y0, (x1 - x0), (y1 - y0));
+        const value_delta = power * direction;
 
         const limitMin = this.settings.limitMin;
         const limitMax = this.settings.limitMax;
 
-        for (let y = y0; y < y1; y++) {
-
-            const v = inverseLerp(h_y0, h_y1, y);
-
-
-            for (let x = x0; x < x1; x++) {
-
-                const u = inverseLerp(h_x0, h_x1, x);
-
-                //Get alpha
-                const markerValue = marker.sampleChannelBilinear(u, v, 3);
-
-                const p = markerValue / 256;
-
-                const address = y * heightMap.width + x;
-
-                const base = heightMap.data[address];
-
-                const patchAddress = (y - y0) * action.patch.width + (x - x0);
-
-                const targetValue = clamp(base + speed, limitMin, limitMax);
-
-                if (markerValue === 0) {
-
-                    action.patch.data[patchAddress] = base;
-
-                } else {
-
-                    const value = lerp(base, targetValue, p);
-
-                    if (Number.isNaN(value)) {
-                        console.warn('.');
-
-                        action.patch.data[patchAddress] = base;
-
-                    } else {
-
-                        action.patch.data[patchAddress] = value;
-
-                    }
-                }
-            }
-
-        }
-
+        const action = make_mod_action(terrain, uv_x0, uv_y0, uv_x1, uv_y1, marker, value_delta, limitMin, limitMax);
 
         this.editor.actions.do(action);
 
@@ -252,12 +264,20 @@ export class TerrainHeightPaintTool extends TerrainPaintTool {
             const tX = leaf.x0 * heightSampler.width;
             const tY = leaf.y0 * heightSampler.height;
 
-            const delta = action.computeDelta(tX, tY);
+            const action_value = action.patch.sampleChannelBicubic(tX - action.x, tY - action.y, 0);
+            const existing_value = heightSampler.sampleChannelBicubic(tY, tY, 0);
+
+            const delta = action_value - existing_value;
 
             if (delta === 0) {
                 continue;
             }
 
+            if (Number.isNaN(delta)) {
+                console.error('Delta is NaN, skipping.', action, tX, tY);
+                continue;
+            }
+
             const tM = new Transform();
             tM.copy(transform);
             tM.position._add(0, delta, 0);

package/editor/tools/paint/TerrainPaintTool.js

@@ -21,7 +21,7 @@ export class TerrainPaintTool extends Tool {
         marker.data.fill(255);
 
         this.settings.markerColor = new Color(0, 1, 0.8);
-        this.settings.markerOpacity = new Vector1(0.5);
+        this.settings.markerOpacity = new Vector1(1);
 
         this.settings.marker = marker;
         this.settings.brushSize = 5;
@@ -128,6 +128,7 @@ export class TerrainPaintTool extends Tool {
         const brushSizeX = brushRadius * dx;
         const brushSizeY = brushRadius * dy;
 
+
         overlay.paintImage(this.__brushImage, overlayPositionX - brushSizeX, overlayPositionY - brushSizeY, brushSize * dx, brushSize * dy);
     }
 

package/editor/tools/paint/TerrainTexturePaintTool.js

@@ -1,10 +1,9 @@
 import { clamp } from "../../../core/math/clamp.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { TerrainPaintTool } from "./TerrainPaintTool.js";
-import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
-import { PatchTerrainTextureAction } from "../../actions/concrete/PatchTerrainTextureAction.js";
 import { convertSampler2D2DataURL } from "../../../engine/graphics/texture/sampler/convertSampler2D2DataURL.js";
 import { obtainTerrain } from "../../../engine/ecs/terrain/util/obtainTerrain.js";
+import { ModifyPatchSampler2DAction } from "../../actions/concrete/ModifyPatchSampler2DAction.js";
 
 export class TerrainTexturePaintTool extends TerrainPaintTool {
     constructor() {
@@ -96,7 +95,6 @@ export class TerrainTexturePaintTool extends TerrainPaintTool {
         const brushPosition = this.__brushPosition;
         const brushSize = this.settings.brushSize;
 
-
         const terrainSize = terrain.size;
 
         const terrainHeight = terrainSize.y;
@@ -126,14 +124,12 @@ export class TerrainTexturePaintTool extends TerrainPaintTool {
          */
         const weightData = this.__splatMapScratch;
 
-
         /**
          *
          * @type {SplatMapping}
          */
         const splat = terrain.splat;
 
-        const splatDepth = splat.depth;
         const splatWidth = splat.size.x;
         const splatHeight = splat.size.y;
 
@@ -153,25 +149,17 @@ export class TerrainTexturePaintTool extends TerrainPaintTool {
 
         const splatIndex = this.settings.splatIndex;
 
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        const materialSampler = splat.materialSampler;
-
         //create action
         const patchWidth = x1 - x0;
-        const patchHeight = y1 - y0;
 
         const targetSplatLayerAddress = splatIndex * splatLayerSize;
 
-        const action = new PatchTerrainTextureAction(terrain, x0, y0, patchWidth, patchHeight);
-        action.patchMaterial.copy_sameItemSize(materialSampler, x0, y0, 0, 0, patchWidth, patchHeight);
+        const splat_layer_sampler = splat.getLayerWeightSampler(splatIndex);
 
-        const patchMaterialData = action.patchMaterial.data;
+        const m_action = new ModifyPatchSampler2DAction(splat_layer_sampler, [x0, y0, x1, y1]);
+
+        const patchMaterialData = m_action.patch.data;
 
-        const a4_weight = new Array(4);
-        const a4_material = new Array(4);
 
         for (let y = y0; y < y1; y++) {
 
@@ -208,68 +196,15 @@ export class TerrainTexturePaintTool extends TerrainPaintTool {
                 weightData[targetSplatLayerAddress + splatTexelIndex] = clampedValue;
 
 
-                for (let i = 0; i < splatDepth; i++) {
-
-                    if (i === splatIndex) {
-                        continue;
-                    }
-
-                    const address = i * splatLayerSize + splatTexelIndex;
-
-                    const v = weightData[address];
-
-                    const cV = clamp(v - delta, 0, 255);
-
-                    weightData[address] = cV;
-
-                }
-
-                a4_weight.fill(-1);
-                a4_material.fill(255);
+                const patchIndex = ((y - y0) * patchWidth + (x - x0));
 
-                //compute materials
-                for (let i = 0; i < splatDepth; i++) {
-
-                    const address = i * splatLayerSize + splatTexelIndex;
-
-                    const weight = weightData[address];
-
-                    if (weight > a4_weight[3]) {
-                        a4_weight[3] = weight;
-                        a4_material[3] = i;
-
-                        for (let j = 3; j >= 0 && weight > a4_weight[j - 1]; j--) {
-                            const tW = a4_weight[j];
-                            const tM = a4_material[j];
-
-                            const j1 = j - 1;
-
-                            a4_weight[j] = a4_weight[j1];
-                            a4_material[j] = a4_material[j1];
-
-                            a4_weight[j1] = tW;
-                            a4_material[j1] = tM;
-                        }
-
-                    }
-
-
-                }
-
-                const patchIndex4 = ((y - y0) * patchWidth + (x - x0)) * 4;
-
-                patchMaterialData[patchIndex4] = a4_material[0];
-                patchMaterialData[patchIndex4 + 1] = a4_material[1];
-                patchMaterialData[patchIndex4 + 2] = a4_material[2];
-                patchMaterialData[patchIndex4 + 3] = a4_material[3];
+                patchMaterialData[patchIndex] = clampedValue;
             }
 
         }
 
 
-        action.readWeights(this.__splatMapScratch, splatWidth, splatHeight);
-
-        this.editor.actions.do(action);
+        this.editor.actions.do(m_action);
     }
 
     start() {

package/engine/asset/AssetManager.d.ts

@@ -12,7 +12,7 @@ export class AssetManager {
 
     clear(): void
 
-    registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<void>
+    registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<AssetLoader<T>>
 
     unregisterLoader(type: string): Promise<void>