@woosh/meep-engine 2.43.1 → 2.43.4

package/engine/graphics/sh3/prototypeSH3Probe.js

@@ -0,0 +1,427 @@
+import { EngineHarness } from "../../EngineHarness.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { GizmoRenderingPlugin } from "../render/gizmo/GizmoRenderingPlugin.js";
+import { LightProbeVolume } from "./LightProbeVolume.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import {
+    ClampToEdgeWrapping,
+    DataTexture,
+    LinearFilter,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    NearestFilter,
+    PlaneBufferGeometry,
+    RGBAFormat,
+    UnsignedByteType
+} from "three";
+import { Transform } from "../../ecs/transform/Transform.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { is_typed_array_equals } from "../../../core/collection/array/typed/is_typed_array_equals.js";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
+import { GLTFAssetLoader } from "../../asset/loaders/GLTFAssetLoader.js";
+import { three_object_to_entity_composition } from "../ecs/mesh-v2/three_object_to_entity_composition.js";
+import { TransformAttachmentSystem } from "../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
+import { delay } from "../../../core/process/delay.js";
+import { make_justified_point_grid } from "../../../core/geom/3d/util/make_justified_point_grid.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { Light } from "../ecs/light/Light.js";
+import { LightType } from "../ecs/light/LightType.js";
+
+/**
+ *
+ * @param {Storage} storage
+ * @param {*} component
+ * @param {BinaryClassSerializationAdapter} adapter
+ * @param {string} key
+ * @param {Signal[]} signals
+ */
+async function persist_component(storage, component, adapter, key = 'temp', signals) {
+
+
+    const current_state = new BinaryBuffer();
+
+    const full_key = `persisted_transform:${key}`;
+
+    if (await storage.promiseContains(full_key)) {
+
+        const loaded = await storage.promiseLoadBinary(full_key);
+
+        const buffer = BinaryBuffer.fromArrayBuffer(loaded);
+
+        adapter.deserialize(buffer, component);
+    }
+
+    // make a binary state copy
+    adapter.serialize(current_state, component);
+
+
+    for (let i = 0; i < signals.length; i++) {
+        signals[i].add(store);
+    }
+
+    function store() {
+
+        const buffer = new BinaryBuffer();
+
+        adapter.serialize(buffer, component);
+
+        buffer.trim();
+
+
+        if (!is_typed_array_equals(current_state.__data_uint8, buffer.__data_uint8)) {
+            // change detected
+
+            storage.promiseStoreBinary(full_key, buffer.data);
+
+
+            current_state.setCapacity(buffer.length);
+            array_copy(buffer.__data_uint8, 0, current_state.__data_uint8, 0, buffer.length);
+        }
+    }
+
+
+}
+
+/**
+ *
+ * @param {number|Vector3} scale
+ * @param {Vector3} offset
+ * @param {Vector3} direction
+ * @param up
+ * @param shadow
+ * @param material
+ * @param {Engine} engine
+ */
+function make_plane({
+                        scale,
+                        offset,
+                        direction = Vector3.forward,
+                        up = Vector3.up,
+                        shadow = true,
+                        material = new MeshBasicMaterial({ color: 0xFFFFFF }),
+                        engine
+                    }) {
+
+    const t1 = Transform.fromJSON({
+        position: offset,
+        scale: scale
+    });
+    t1.rotation.lookRotation(direction, up);
+
+    if (engine) {
+        material = engine.graphics.getMaterialManager().obtain(material).getValue();
+    }
+
+    const sg = ShadedGeometry.from(new PlaneBufferGeometry(), material);
+
+    sg.writeFlag(ShadedGeometryFlags.CastShadow, shadow);
+    sg.writeFlag(ShadedGeometryFlags.ReceiveShadow, shadow);
+
+    return new EntityBuilder()
+        .add(sg)
+        .add(t1);
+
+}
+
+function make_cornel_box(ecd) {
+
+
+    make_plane({
+        scale: 20,
+        offset: new Vector3(10, 10, 0),
+        direction: Vector3.forward,
+        material: new MeshBasicMaterial({ color: 0xFF0000 })
+    }).build(ecd);
+    make_plane({
+        scale: 20,
+        offset: new Vector3(10, 10, 20),
+        direction: Vector3.left,
+        material: new MeshBasicMaterial({ color: 0x00FF00 })
+    }).build(ecd);
+    make_plane({
+        scale: 20,
+        offset: new Vector3(0, 10, 10),
+        direction: Vector3.right,
+        material: new MeshBasicMaterial({ color: 0xFFFFFF })
+    }).build(ecd);
+
+}
+
+function make_test_texture(t = 1) {
+    const t1 = (1 - t) * 0.5;
+    const tex = new DataTexture(new Uint8ClampedArray([
+        255 * t, 255 * t1, 255 * t1, 255,
+        255 * t1, 255 * t, 255 * t1, 255,
+        255 * t1, 255 * t1, 255 * t, 255,
+        255 * t, 255 * t, 255 * t1, 255
+    ]), 2, 2, RGBAFormat, UnsignedByteType);
+
+    tex.flipY = false;
+    tex.wrapS = ClampToEdgeWrapping;
+    tex.wrapT = ClampToEdgeWrapping;
+    tex.magFilter = NearestFilter;
+    tex.minFilter = LinearFilter;
+    tex.generateMipmaps = false;
+
+    tex.needsUpdate = true;
+
+    return tex;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: false,
+        enableLights: false,
+        cameraFarDistance: 200,
+        focus: { x: 0, y: 0, z: 0 },
+        pitch: 0.5500000000000453,
+        yaw: -2.4300000000000566,
+        distance: 10,
+        shadowmapResolution: 4096
+    });
+
+    const ecd = engine.entityManager.dataset;
+
+
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    const path = 'data/models/sibenik/model.gltf';
+    // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+    // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
+    // const path = 'data/models/Slaughter Mech/Slaugter Mech.gltf';
+
+    const mesh_asset = await engine.assetManager.promise(path, 'gltf');
+    const gltf = mesh_asset.gltf;
+
+
+    const composition = three_object_to_entity_composition(gltf.scene);
+
+    composition.traverse(n => {
+
+        /**
+         * @type {ShadedGeometry}
+         */
+        const sg = n.entity.getComponent(ShadedGeometry);
+
+        if (sg !== null) {
+            sg.setFlag(ShadedGeometryFlags.CastShadow);
+            sg.setFlag(ShadedGeometryFlags.ReceiveShadow);
+        }
+    });
+
+
+    // model_bounds.setNegativelyInfiniteBounds();
+    // composition.traverse((n) => {
+    //
+    //     /**
+    //      * @type {ShadedGeometry}
+    //      */
+    //     const sg = n.entity.getComponent(ShadedGeometry);
+    //
+    //     if (sg !== null) {
+    //         const aabb3 = new AABB3();
+    //         sg.getBoundingBox(aabb3);
+    //
+    //         model_bounds.expandToFit(aabb3);
+    //     }
+    // })
+
+    composition.transform.scale.setScalar(1);
+    composition.transform.position.set(0, -mesh_asset.boundingBox.y0, 0);
+
+    composition.build(ecd);
+
+    const model_footprint = Math.hypot(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ());
+
+
+    make_plane({
+        engine,
+        scale: 2 * model_footprint,
+        offset: new Vector3(0, 0, 0),
+        direction: Vector3.up,
+        up: Vector3.forward,
+        material: new MeshStandardMaterial({
+            color: 0x111111,
+            // map: make_test_texture()
+        })
+    }).build(ecd);
+
+    //
+    // make_plane({
+    //     scale: 3 * model_footprint,
+    //     offset: new Vector3(0, mesh_asset.boundingBox.y1 + 2, 0),
+    //     direction: Vector3.down,
+    //     up: Vector3.forward,
+    //     shadow: false,
+    //     material: new MeshStandardMaterial({ color: '#c6f5ff' })
+    // }).build(ecd);
+
+    const points = [
+        0, 0, 0,
+        10, 0, 0,
+        10, 0, 10,
+        0, 0, 10,
+
+        0, 10, 0,
+        10, 10, 0,
+        10, 10, 10,
+        0, 10, 10,
+    ];
+
+    //
+    // new EntityBuilder()
+    //     .add(Transform.fromJSON({
+    //         position: {
+    //             x: mesh_asset.boundingBox.x0,
+    //             y: mesh_asset.boundingBox.getCenterY(),
+    //             z: mesh_asset.boundingBox.getCenterZ()
+    //         }
+    //     }))
+    //     .add(Light.fromJSON({
+    //         distance: model_footprint * 2,
+    //         type: LightType.POINT,
+    //         intensity: 10,
+    //         color: 0xFF0000
+    //     }))
+    //     .build(ecd);
+    //
+    // new EntityBuilder()
+    //     .add(Transform.fromJSON({
+    //         position: {
+    //             x: mesh_asset.boundingBox.x1,
+    //             y: mesh_asset.boundingBox.getCenterY(),
+    //             z: mesh_asset.boundingBox.getCenterZ()
+    //         }
+    //     }))
+    //     .add(Light.fromJSON({
+    //         distance: model_footprint * 2,
+    //         type: LightType.POINT,
+    //         intensity: 10,
+    //         color: '#00f7ff'
+    //     }))
+    //     .build(ecd);
+
+    const random = seededRandom();
+
+    for (let i = 0; i < 16; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, mesh_asset.boundingBox.x0, mesh_asset.boundingBox.x1),
+                    y: randomFloatBetween(random, mesh_asset.boundingBox.y0, mesh_asset.boundingBox.y1),
+                    z: randomFloatBetween(random, mesh_asset.boundingBox.z0, mesh_asset.boundingBox.z1),
+                }
+            }))
+            .add(Light.fromJSON({
+                distance: model_footprint *0.2,
+                type: LightType.POINT,
+                intensity: 1,
+                color: `hsv(${random()},${1},1)`
+            }))
+            .build(ecd);
+    }
+
+
+    const lpv = new LightProbeVolume();
+
+    // lpv.add_point(10, 5, 10);
+
+    const desired_density = 15;
+
+
+    // const light_volume_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    const probe_grid_spacing_dense = Math.min(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ()) / desired_density;
+    const probe_grid_spacing_sparse = Math.max(mesh_asset.boundingBox.getExtentsX(), mesh_asset.boundingBox.getExtentsY(), mesh_asset.boundingBox.getExtentsZ()) / desired_density;
+
+    const probe_grid_spacing = (probe_grid_spacing_sparse / probe_grid_spacing_dense) < 2 ? probe_grid_spacing_dense : probe_grid_spacing_sparse * 0.5;
+    //
+    // const probe_grid_spacing =desired_density/ (mesh_asset.boundingBox.getExtentsX()* mesh_asset.boundingBox.getExtentsY()* mesh_asset.boundingBox.getExtentsZ());
+
+    const model_bounds = new AABB3(-10, 0.5, -10, 10, 11, 10);
+    model_bounds.copy(mesh_asset.boundingBox);
+    model_bounds.grow(probe_grid_spacing * 1.1);
+
+
+    // sg_hierarchy_compute_bounding_box_via_parent_entity(light_volume_bounds, composition.entity.entity, ecd);
+
+    // for (let i = 0; i < 100; i++) {
+    //     lpv.add_point(
+    //         randomFloatBetween(random, light_volume_bounds.x0, light_volume_bounds.x1),
+    //         randomFloatBetween(random,  light_volume_bounds.y0, light_volume_bounds.y1),
+    //         randomFloatBetween(random,  light_volume_bounds.z0, light_volume_bounds.z1),
+    //     );
+    // }
+
+    make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
+        lpv.add_point(x, y, z);
+    });
+
+    // lpv.add_point(10, 1, -10);
+
+    await delay(2000);
+
+    //
+    // console.profile('lpv build');
+    //
+    lpv.build(engine);
+    // console.profileEnd('lpv build');
+
+    // fill probes with random data
+    // for (let i = 0; i < lpv.__length * 27; i++) {
+    //     lpv.__probe_data[i] = random();
+    // }
+
+    // for (let i = 0; i < lpv.__length; i++) {
+    //
+    //     for (let j = 0; j < 9; j++) {
+    //         lpv.__probe_data[(i * 9 + j) * 3] = max2(0, (lpv.__positions[i * 3] + 10) / 20);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 1] = max2(0, (lpv.__positions[i * 3 + 1] - 0.5) / 10.5);
+    //         lpv.__probe_data[(i * 9 + j) * 3 + 2] = max2(0, (lpv.__positions[i * 3 + 2] + 10) / 20);
+    //     }
+    // }
+
+    // lpv.white_probe(0, [
+    //     0.7953949, 0.4405923, 0.5459412,
+    //     0.3981450, 0.3526911, 0.6097158,
+    //     -0.3424573, -0.1838151, -0.2715583,
+    //
+    //     -0.2944621, -0.0560606, 0.0095193,
+    //     -0.1123051, -0.0513088, -0.1232869,
+    //     -0.2645007, -0.2257996, -0.4785847,
+    //
+    //     -0.1569444, -0.0954703, -0.1485053,
+    //     0.5646247, 0.2161586, 0.1402643,
+    //     0.2137442, -0.0547578, -0.3061700], 0);
+
+
+    // lpv.visualize_mesh({ ecd: ecd });
+    lpv.visualize_probes({ ecd: ecd, size: probe_grid_spacing * 0.08 });
+
+
+    console.log(lpv);
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addSystem(new TransformAttachmentSystem());
+        config.addSystem(new LightSystem(engine));
+
+        config.addLoader('gltf', new GLTFAssetLoader());
+
+        config.addPlugin(GizmoRenderingPlugin);
+    }
+}).then(main);

package/engine/graphics/sh3/visualise_probe.js

@@ -0,0 +1,40 @@
+import { SH3VisualisationMaterial } from "./SH3VisualisationMaterial.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import { OctahedronBufferGeometry } from "three";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+
+/**
+ *
+ * @param {number} [size]
+ * @param position
+ * @param position_offset
+ * @param sh
+ * @param sh_offset
+ * @return {EntityBuilder}
+ */
+export function visualise_probe({ size = 1,shadow=false, position, position_offset = 0, sh, sh_offset = 0 }) {
+
+    const mat = new SH3VisualisationMaterial();
+
+    for (let i = 0; i < 9; i++) {
+        mat.uniforms.sh.value[i].fromArray(sh, sh_offset + i * 3);
+    }
+
+    const shadedGeometry = ShadedGeometry.from(new OctahedronBufferGeometry(1, 5), mat);
+
+    shadedGeometry.writeFlag(ShadedGeometryFlags.ReceiveShadow,shadow);
+    shadedGeometry.writeFlag(ShadedGeometryFlags.CastShadow,shadow);
+
+    return new EntityBuilder()
+        .add(Transform.fromJSON({
+            position: {
+                x: position[position_offset],
+                y: position[position_offset + 1],
+                z: position[position_offset + 2],
+            },
+            scale: size
+        }))
+        .add(shadedGeometry);
+}

package/engine/graphics/shaders/DenoiseShader.js

@@ -60,7 +60,7 @@ void main(void) {
 `;
 
 /**
- *
+ * Normal Probability Distribution Function
  * @param {number} x
  * @param {number} sigma
  * @return {number}

package/engine/graphics/texture/atlas/AtlasPatch.js

@@ -31,7 +31,7 @@ export class AtlasPatch {
         this.id = -1;
 
         /**
-         *
+         * Texture data of the patch, this is what will be stenciled into the atlas
          * @type {Sampler2D|null}
          */
         this.sampler = null;
@@ -43,8 +43,9 @@ export class AtlasPatch {
         this.uv = new Rectangle(0, 0, 0, 0);
 
         /**
-         * Area in the atlas where patch along with the padding is packed into
-         * Used for packing inside TextureAtlas. Do not modify manually
+         * Area in the atlas where patch along with the padding is packed into.
+         * Used for packing inside TextureAtlas.
+         * Do not modify manually
          * @readonly
          * @protected
          * @type {AABB2}
@@ -56,6 +57,13 @@ export class AtlasPatch {
          * @type {number|AtlasPatchFlag}
          */
         this.flags = 0;
+
+        /**
+         * Version of associated sampler that was last written.
+         * Used to track and signal when sampler needs to be re-painted.
+         * @type {number}
+         */
+        this.last_painted_version = -1;
     }
 
     /**

package/engine/graphics/texture/atlas/CachingTextureAtlas.js

@@ -171,7 +171,7 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
 
         const target = this.__find_replacement_target(width, height);
 
-        if (target) {
+        if (target !== -1) {
             // evicted just one element
             this.__evict(target);
             return true;
@@ -228,7 +228,7 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
     }
 
     reset() {
-        this.__cached_patches.splice(i, this.__cached_patches.length);
+        this.__cached_patches.splice(0, this.__cached_patches.length);
         this.__atals.reset();
     }
 

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -20,11 +20,16 @@ export class TextureAtlas extends AbstractTextureAtlas {
      *
      * @param {number} [size]
      * @param {DataType} [data_type]
+     * @param {number} [channel_count]
      * @constructor
      */
-    constructor(size = 16, data_type = DataType.Uint8) {
+    constructor(size = 16, data_type = DataType.Uint8, channel_count = 4) {
         super();
 
+        assert.isNonNegativeInteger(size, 'size');
+        assert.enum(data_type, DataType, 'data_type');
+        assert.isNonNegativeInteger(channel_count, 'channel_count');
+
         /**
          *
          * @type {IdPool}
@@ -46,8 +51,6 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         const TypeArrayConstructor = DataType2TypedArrayConstructorMapping[data_type];
 
-        const channel_count = 4;
-
         /**
          * @private
          * @readonly
@@ -150,6 +153,9 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @returns {boolean} true if resizing successful, false otherwise
      */
     resize(x, y) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
+
         //check if any patches would be cut
         const patches = this.patches;
         const numPatches = patches.length;
@@ -210,6 +216,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
         );
 
         patch.setFlag(AtlasPatchFlag.Painted);
+        patch.last_painted_version = source.version; // record version
 
         // console.timeEnd('TextureAtlas.paintPatch');
     }
@@ -254,6 +261,12 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @return {AtlasPatch}
      */
     add(sampler, padding = 4) {
+
+        assert.notNull(sampler, 'sampler');
+        assert.defined(sampler, 'sampler');
+
+        assert.isNonNegativeInteger(padding, 'padding');
+
         // console.log('#add');
 
         const patch = new AtlasPatch();
@@ -462,10 +475,15 @@ export class TextureAtlas extends AbstractTextureAtlas {
         for (let i = 0; i < l; i++) {
             const patch = patches[i];
 
-            if (!patch.getFlag(AtlasPatchFlag.Painted)) {
+            if (
+                !patch.getFlag(AtlasPatchFlag.Painted)
+                || patch.last_painted_version !== patch.sampler.version
+            ) {
+
                 this.paintPatch(patch);
 
                 paintCount++;
+
             }
         }
 

package/engine/graphics/texture/atlas/TextureAtlas.spec.js

@@ -249,3 +249,25 @@ test("add 7 patches an update each time", () => {
     }
 
 });
+
+test("modified sampler get repainted during 'paint'", () => {
+    const atlas = new TextureAtlas();
+
+    const sampler = Sampler2D.uint8(4, 1, 1);
+
+    sampler.data.fill(7);
+
+    const patch = atlas.add(sampler);
+
+    atlas.update();
+
+    // modify sampler
+    sampler.data.fill(3);
+    sampler.version++;
+
+    atlas.paint(); //repaint
+
+    const v0 = atlas.sampler.readChannel(patch.position.x, patch.position.y, 0)
+
+    expect(v0).toBe(3);
+});

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -1646,70 +1646,6 @@ export class Sampler2D {
         return sampler;
     }
 
-    /**
-     *
-     * @param {Sampler2D} input0
-     * @param {Sampler2D} input1
-     * @param {Sampler2D} result
-     * @param {function( value0 : number[], value1 : number[], result : number[], index : number) : void} operation
-     */
-    static combine(input0, input1, result, operation) {
-        assert.notEqual(input0, undefined, "input0 is undefined");
-        assert.notEqual(input1, undefined, "input1 is undefined");
-        assert.notEqual(result, undefined, "result is undefined");
-
-        assert.typeOf(operation, "function", "operation");
-
-        assert.equal(input0.width, input1.width, `input0.width(=${input0.width}) is not equal to input1.width(=${input1.width})`);
-        assert.equal(input0.height, input1.height, `input0.height(=${input0.height}) is not equal to input1.height(=${input1.height})`);
-
-        assert.equal(input0.width, result.width, `input width(=${input0.width}) is not equal to result.width(=${result.width})`);
-        assert.equal(input0.height, result.height, `input height(=${input0.height}) is not equal to result.height(=${result.height})`);
-
-        const width = input0.width;
-        const height = input0.height;
-
-        const length = width * height;
-
-        const arg0 = [];
-        const arg1 = [];
-        const res = [];
-
-        const itemSize0 = input0.itemSize;
-        const itemSize1 = input1.itemSize;
-        const itemSizeR = result.itemSize;
-
-        const data0 = input0.data;
-        const data1 = input1.data;
-        const dataR = result.data;
-
-
-        let i, j;
-
-        for (i = 0; i < length; i++) {
-
-            // read input 0
-            for (j = 0; j < itemSize0; j++) {
-                arg0[j] = data0[j + i * itemSize0];
-            }
-
-            // read input 1
-            for (j = 0; j < itemSize0; j++) {
-                arg1[j] = data1[j + i * itemSize1];
-            }
-
-            //perform operation
-            operation(arg0, arg1, res, i);
-
-            //write result
-            for (j = 0; j < itemSizeR; j++) {
-                dataR[j + i * itemSizeR] = res[j];
-            }
-
-        }
-
-        result.version++;
-    }
 }