@woosh/meep-engine 2.46.29 → 2.46.30

package/editor/tools/paint/TerrainTexturePaintTool.js

@@ -0,0 +1,193 @@
+import { TerrainPaintTool } from "./TerrainPaintTool.js";
+import { convertSampler2D2DataURL } from "../../../src/engine/graphics/texture/sampler/convertSampler2D2DataURL.js";
+import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
+import { ModifyPatchTextureArray2DAction } from "../../actions/concrete/ModifyPatchTextureArray2DAction.js";
+import { ArrayCopyAction } from "../../actions/concrete/ArrayCopyAction.js";
+import { ActionUpdateTexture } from "../../actions/concrete/ActionUpdateTexture.js";
+
+export class TerrainTexturePaintTool extends TerrainPaintTool {
+    constructor() {
+        super();
+
+        this.name = "texture-paint-terrain";
+
+        /**
+         *
+         * @type {number}
+         */
+        this.settings.splatIndex = 0;
+
+        /**
+         *
+         * @type {Float32Array}
+         * @private
+         */
+        this.__splatMapScratch = new Float32Array(0);
+
+        this.__iconLayer = null;
+    }
+
+
+    updateIcon(editor) {
+
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = obtainTerrain(editor.engine.entityManager.dataset);
+
+        if (terrain === null) {
+            // no terrain
+            return;
+        }
+
+        /**
+         *
+         * @type {TerrainLayer}
+         */
+        const layer = terrain.layers.get(this.settings.splatIndex);
+
+        if (layer === this.__iconLayer) {
+            return;
+        }
+
+        this.__iconLayer = layer;
+
+        this.buildIcon(terrain);
+    }
+
+    /**
+     *
+     * @param {Terrain} terrain
+     */
+    buildIcon(terrain) {
+
+        /**
+         *
+         * @type {TerrainLayer}
+         */
+        const layer = terrain.layers.get(this.settings.splatIndex);
+
+        if (layer === undefined) {
+            return;
+        }
+
+        const url = convertSampler2D2DataURL(layer.diffuse);
+
+        this.icon.set(url);
+    }
+
+    initialize() {
+        super.initialize();
+    }
+
+    shutdown() {
+        super.shutdown();
+    }
+
+    async paint(timeDelta) {
+
+        const power = this.settings.brushStrength * timeDelta;
+
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = this.terrain;
+
+        const brushPosition = this.__brushPosition;
+        const brushSize = this.settings.brushSize;
+
+        const terrainSize = terrain.size;
+
+        const terrainHeight = terrainSize.y;
+        const terrainWidth = terrainSize.x;
+
+        const uv_x = brushPosition.x / terrainWidth;
+        const uv_y = brushPosition.y / terrainHeight;
+
+        const uv_w = brushSize / terrainWidth;
+        const uv_h = brushSize / terrainHeight;
+
+        const uv_x0 = uv_x - uv_w / 2;
+        const uv_x1 = uv_x + uv_w / 2;
+
+        const uv_y0 = uv_y - uv_h / 2;
+        const uv_y1 = uv_y + uv_h / 2;
+
+        const marker = this.settings.marker;
+
+        const direction = this.modifiers.shift ? -1 : 1;
+
+        const speed = power * direction;
+
+        /**
+         *
+         * @type {Float32Array}
+         */
+        const weightData = this.__splatMapScratch;
+
+        /**
+         *
+         * @type {SplatMapping}
+         */
+        const splat = terrain.splat;
+
+        const splatWidth = splat.size.x;
+        const splatHeight = splat.size.y;
+
+
+        const h_x0 = uv_x0 * splatWidth;
+        const h_x1 = uv_x1 * splatWidth;
+
+        const h_y0 = uv_y0 * splatHeight;
+        const h_y1 = uv_y1 * splatHeight;
+
+        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 splatIndex = this.settings.splatIndex;
+
+        //create action
+
+        // const m_action = new ModifyPatchSampler2DAction(splat_layer_sampler, [x0, y0, x1, y1]);
+        const m_action = new ModifyPatchTextureArray2DAction(weightData, [splat.size.x, splat.size.y, splat.depth], [x0, y0, x1, y1]);
+
+        m_action.applyWeightStampToLayer(
+            uv_x * splat.size.x, uv_y * splat.size.y,
+            marker, splatIndex, speed,
+            0, 255
+        );
+
+        await this.editor.actions.doMany([
+            m_action,
+            new ArrayCopyAction(weightData, splat.weightData),
+            new ActionUpdateTexture(splat.weightTexture)
+        ]);
+    }
+
+    start() {
+        super.start();
+
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = this.terrain;
+
+        const splat = terrain.splat;
+
+        const weightData = splat.weightData;
+
+        /**
+         *
+         * @type {Float32Array}
+         */
+        this.__splatMapScratch = new Float32Array(weightData);
+
+        this.editor.actions.mark('paint terrain texture');
+    }
+}

package/editor/tools/paint/prototypeTerrainEditor.js

@@ -0,0 +1,135 @@
+import { EngineHarness } from "../../../src/engine/EngineHarness.js";
+import { GizmoRenderingPlugin } from "../../../src/engine/graphics/render/gizmo/GizmoRenderingPlugin.js";
+import { GameAssetType } from "../../../src/engine/asset/GameAssetType.js";
+import { TextureAssetLoader } from "../../../src/engine/asset/loaders/texture/TextureAssetLoader.js";
+import Vector2 from "../../../src/core/geom/Vector2.js";
+import { enableEditor } from "../../enableEditor.js";
+import { initializeEditor } from "../../../../model/game/initializeEditor.js";
+
+import '../../../../../../css/game.scss';
+import '../../../../../../css/editor/EntityEditorView.scss';
+import '../../../../../../css/editor/EditorView.scss';
+import { TerrainLayer } from "../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js";
+import Terrain from "../../../src/engine/ecs/terrain/ecs/Terrain.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+import { BlenderCameraOrientationGizmo } from "../v2/BlenderCameraOrientationGizmo.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import TopDownCameraController from "../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+
+new EngineHarness()
+    .initialize({
+        configuration(config, engine) {
+
+            config.addPlugin(GizmoRenderingPlugin);
+
+            config.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+        }
+    }).then(main);
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        focus: new Vector3(128, 0, 128),
+        distance: 30,
+        terrainResolution: 1,
+        terrainSize: new Vector2(128, 128),
+        enableWater: false
+    });
+
+    const ecd = engine.entityManager.dataset;
+    const terrain_entity = ecd.getAnyComponent(Terrain);
+    const terrain = terrain_entity.component;
+
+    terrain.samplerHeight.resize(256, 256);
+    await terrain.updateHeights();
+
+
+    terrain.layers.addLayer(TerrainLayer.from("data/textures/materials/terrain_township_set/512/Grass_1.png", 20, 20));
+    terrain.layers.addLayer(TerrainLayer.from("data/textures/materials/terrain_township_set/512/Ground_1.png", 20, 20));
+    terrain.layers.addLayer(TerrainLayer.from("data/textures/materials/RAYGEAS/Stylized Ground Textures/Sand_2/Sand_2_AlbedoSmoothness.png", 20, 20));
+    terrain.layers.buildTexture();
+
+
+    terrain.splat.resize(256, 256, terrain.layers.count())
+
+    await terrain.layers.loadTextureData(engine.assetManager);
+
+    terrain.splat.fillLayerWeights(0, 50);
+
+    terrain.splat.weightTexture.needsUpdate = true;
+    terrain.updateMaterial();
+
+    const editor_controls = enableEditor(engine, initializeEditor);
+
+    editor_controls.enable();
+
+    const camera_orientation_gizmo = new BlenderCameraOrientationGizmo();
+
+    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,50 @@
+import View, {IViewSignals} from "../../../src/view/View";
+import Quaternion from "../../../src/core/geom/Quaternion";
+import Signal from "../../../src/core/events/signal/Signal";
+
+interface ISignals extends IViewSignals {
+    readonly axisSelected: Signal<string>
+}
+
+interface IDirectionStyle {
+    near_fill?: string
+    near_stroke_width?: number
+    near_stroke_color?: string
+
+    far_fill?: string
+    far_stroke_width?: number
+    far_stroke_color?: string
+}
+
+interface IOptions {
+    size?: number,
+    padding?: number,
+    bubbleSizePrimary?: number,
+    bubbleSizeSecondary?: number,
+    lineWidth?: number,
+    fontSize?: string,
+    fontFamily?: string,
+    fontWeight?: string,
+    fontColor?: string,
+    fontYAdjust?: number,
+    selectionFontColor?: string,
+    axisStyles?: {
+        px?: IDirectionStyle,
+        py?: IDirectionStyle,
+        pz?: IDirectionStyle,
+
+        nx?: IDirectionStyle,
+        ny?: IDirectionStyle,
+        nz?: IDirectionStyle,
+    }
+}
+
+export class BlenderCameraOrientationGizmo extends View {
+    constructor(options?: IOptions)
+
+    on: ISignals
+
+    orientation: Quaternion | null
+
+    update(): void
+}