@woosh/meep-engine 3.39.0 → 3.41.0

package/src/shade/renderer/water/surface/shader_water_wave_domain.js

@@ -0,0 +1,83 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { chunk_ray_query_blas_nearest } from "../../shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WATER_WAVES_TABLE as table } from "../medium/chunk_water_bodies.js";
+import { WATER_WAVE_BATCH_STRUCT } from "./shader_water_wave_batch.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('blas_lookup', WebGPUArray.u32)
+    .addStorageBuffer('blas_data', WebGPUArray.from(BVH2_NODE_STRUCT))
+    .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+    .addStorageBuffer('domain', WebGPUArray.u32, true);
+
+/** Bake the authored footprint once per new wave row, using the existing geometry BLAS. */
+export const shader_water_wave_domain = ComputeShader.from({ label: 'Water / authored simulation domain', resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    let n = batch.resolution;
+    let row = i / (n * n);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read}(&scene_database, row);
+    if (params.node == 0u || params.node == ~0u) { domain[i] = 0u; return; }
+    if (params.first_write == 0u && batch.apply_impulses == 0u) { return; }
+    let geometry = geometries[params.geometry];
+    let cell = vec2u(i % n, (i / n) % n);
+    let xz = mix(params.extent.xy, params.extent.zw, vec2f(cell) / f32(n - 1u));
+    let margin = max(1e-3, (geometry.bounding_box[4] - geometry.bounding_box[1]) * 1e-4);
+    let top = geometry.bounding_box[4] + margin;
+    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+    let hit = ray_query_blas_nearest(Ray(vec3f(xz.x, top, xz.y), vec3f(0.0, -1.0, 0.0),
+        top - geometry.bounding_box[1] + margin), params.geometry, &stack, 0u);
+    domain[i] = select(0u, 1u, hit.t >= 0.0);
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_ray_query_blas_nearest]) });
+
+const bounds_resources = new ShaderResourceSetDescriptor();
+bounds_resources.createGroup().addUniform('batch', WATER_WAVE_BATCH_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32, true)
+    .addStorageBuffer('state', WebGPUArray.from(f32));
+
+/** Bilinear reconstruction cannot leave the extrema of its samples. Include the rest surface. */
+export const shader_water_wave_bounds = ComputeShader.from({ label: 'Water / displacement bounds', resources: bounds_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+var<workgroup> lower: array<f32, 128>;
+var<workgroup> upper: array<f32, 128>;
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let row = folded_workgroup_index(group);
+    if (row >= batch.capacity) { return; }
+    let params = ${table.marshalling_method_read_rw}(&scene_database, row);
+    let occupied = params.node != 0u && params.node != ~0u;
+    let size = select(0u, batch.resolution * batch.resolution, occupied);
+    var lo = 0.0;
+    var hi = 0.0;
+    for (var cell = lane; cell < size; cell += 128u) {
+        let h = state[row * size + cell];
+        lo = min(lo, h); hi = max(hi, h);
+    }
+    lower[lane] = lo; upper[lane] = hi;
+    workgroupBarrier();
+    for (var stride = 64u; stride != 0u; stride /= 2u) {
+        if (lane < stride) {
+            lower[lane] = min(lower[lane], lower[lane + stride]);
+            upper[lane] = max(upper[lane], upper[lane + stride]);
+        }
+        workgroupBarrier();
+    }
+    if (lane == 0u && occupied) { ${table.marshalling_method_write_field('displacement_bounds')}(&scene_database, row, vec2f(lower[0], upper[0])); }
+}
+`, [table.chunk_read_rw, table.wgsl_gen_write_field_code('displacement_bounds'), chunk_folded_workgroup_index]) });

package/src/shade/renderer/water/water_height_texture_from_sampler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"water_height_texture_from_sampler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_height_texture_from_sampler.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uEAFa,YAAY,CA4BxB;6BAnD4B,4BAA4B"}
+{"version":3,"file":"water_height_texture_from_sampler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/water_height_texture_from_sampler.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uEAFa,YAAY,CA8BxB;6BArD4B,4BAA4B"}

package/src/shade/renderer/water/water_height_texture_from_sampler.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../core/assert.js";
-import { to_half_float_uint16 } from "../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { ColorSpace } from "../texture/ColorSpace.js";
 import { ShadeTexture } from "../texture/ShadeTexture.js";
@@ -36,10 +35,12 @@ export function water_height_texture_from_sampler(sampler) {
 
     const count = sampler.width * sampler.height;
 
-    const data = new Uint16Array(count);
+    const data = new Float16Array(count);
 
     for (let i = 0; i < count; i++) {
-        data[i] = to_half_float_uint16(source[i]);
+        const value = source[i];
+        // Keep finite heights inside binary16's range without changing special values.
+        data[i] = Number.isFinite(value) ? Math.min(Math.max(value, -65504), 65504) : value;
     }
 
     const image = ShadeImage.fromArrayBuffer(

package/src/engine/ecs/ik/IKConstraint.d.ts

@@ -1,52 +0,0 @@
-export class IKConstraint {
-    /**
-     * End bone that is going to be placed
-     * @type {String}
-     */
-    effector: string;
-    /**
-     * How far should effector be from the contact, positive values result in effector not reaching the surface, and negative result in penetration
-     * @example For a foot effector this would be distance above the ground
-     * @type {number}
-     */
-    offset: number;
-    /**
-     * Positive distance from the surface at which IK starts to take effect, low value represents full effect and high value represents where the influence begins
-     * @type {NumericInterval}
-     */
-    distance: NumericInterval;
-    /**
-     *
-     * @type {number}
-     */
-    strength: number;
-    /**
-     *
-     * @type {number}
-     */
-    limit: number;
-    /**
-     * Solver to be used for this constraint
-     * @type {string}
-     */
-    solver: string;
-    /**
-     *
-     * @param {IKConstraint} other
-     */
-    copy(other: IKConstraint): void;
-    clone(): IKConstraint;
-    /**
-     *
-     * @param {IKConstraint} other
-     * @returns {boolean}
-     */
-    equals(other: IKConstraint): boolean;
-    /**
-     *
-     * @return {number}
-     */
-    hash(): number;
-}
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-//# sourceMappingURL=IKConstraint.d.ts.map

package/src/engine/ecs/ik/IKConstraint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKConstraint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKConstraint.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,iBAAc;IAEd;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,UAFU,eAAe,CAEY;IAErC;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,QAFU,MAAM,CAEA;IAGhB;;;OAGG;IACH,YAFW,YAAY,QAStB;IAED,sBAMC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAWjB;CACJ;gCA7F+B,gDAAgD"}

package/src/engine/ecs/ik/IKConstraint.js

@@ -1,95 +0,0 @@
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
-
-export class IKConstraint {
-
-    /**
-     * End bone that is going to be placed
-     * @type {String}
-     */
-    effector = "";
-
-    /**
-     * How far should effector be from the contact, positive values result in effector not reaching the surface, and negative result in penetration
-     * @example For a foot effector this would be distance above the ground
-     * @type {number}
-     */
-    offset = 0;
-
-    /**
-     * Positive distance from the surface at which IK starts to take effect, low value represents full effect and high value represents where the influence begins
-     * @type {NumericInterval}
-     */
-    distance = new NumericInterval(0, 0);
-
-    /**
-     *
-     * @type {number}
-     */
-    strength = 1;
-
-    /**
-     *
-     * @type {number}
-     */
-    limit = Math.PI;
-
-    /**
-     * Solver to be used for this constraint
-     * @type {string}
-     */
-    solver = "2BIK";
-
-
-    /**
-     *
-     * @param {IKConstraint} other
-     */
-    copy(other) {
-        this.effector = other.effector;
-        this.offset = other.offset;
-        this.distance.copy(other.distance);
-        this.strength = other.strength;
-        this.limit = other.limit;
-        this.solver = other.solver;
-    }
-
-    clone() {
-        const r = new IKConstraint();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {IKConstraint} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.effector === other.effector
-            && this.offset === other.offset
-            && this.distance.equals(other.distance)
-            && this.strength === other.strength
-            && this.limit === other.limit
-            && this.solver === other.solver;
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    hash() {
-        return combine_hash(
-            computeStringHash(this.effector),
-            computeHashFloat(this.offset),
-            this.distance.hash(),
-            computeHashFloat(this.strength),
-            computeHashFloat(this.limit),
-            computeStringHash(this.solver)
-        );
-    }
-}

package/src/engine/ecs/ik/IKProblem.d.ts

@@ -1,45 +0,0 @@
-export class IKProblem {
-    /**
-     *
-     * @type {IKConstraint}
-     */
-    constraint: IKConstraint;
-    /**
-     * Where the hierarchy lives. Bones are entities, so the chain is walked here rather than on a
-     * skeleton object.
-     *
-     * @type {EntityComponentDataset}
-     */
-    dataset: EntityComponentDataset;
-    /**
-     * The bone being placed. Its ancestors are the rest of the chain, reached through
-     * {@link transform_attachment_parent_of}.
-     *
-     * @type {number}
-     */
-    effector: number;
-    /**
-     *
-     * @type {Terrain}
-     */
-    terrain: Terrain;
-    /**
-     * The clips playing on the constrained entity's model, with their times and weights: what a
-     * chain under a GPU-composed ancestor is evaluated against. Empty for a model nothing plays.
-     *
-     * @type {PosePlayback[]}
-     */
-    playbacks: PosePlayback[];
-    /**
-     * The system's per-tick evaluation cache, shared by every problem of the tick; null where a
-     * chain is evaluated on its own.
-     *
-     * @type {T64WorldCache|null}
-     */
-    cache: T64WorldCache | null;
-}
-export namespace IKProblem {
-    let pool: ObjectPoolFactory<IKProblem>;
-}
-import { ObjectPoolFactory } from "../../../core/model/object/ObjectPoolFactory.js";
-//# sourceMappingURL=IKProblem.d.ts.map

package/src/engine/ecs/ik/IKProblem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKProblem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKProblem.js"],"names":[],"mappings":"AAGA;IAEI;;;OAGG;IACH,yBAAkB;IAElB;;;;;OAKG;IACH,gCAAe;IAEf;;;;;OAKG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,iBAAe;IAEf;;;;;OAKG;IACH,WAFU,cAAc,CAET;IAEf;;;;;OAKG;IACH,OAFU,gBAAc,IAAI,CAEf;CAEhB;;cAIS,kBAAkB,SAAS,CAAC;;kCApDJ,iDAAiD"}

package/src/engine/ecs/ik/IKProblem.js

@@ -1,58 +0,0 @@
-import { noop } from "../../../core/function/noop.js";
-import { ObjectPoolFactory } from "../../../core/model/object/ObjectPoolFactory.js";
-
-export class IKProblem {
-
-    /**
-     *
-     * @type {IKConstraint}
-     */
-    constraint = null;
-
-    /**
-     * Where the hierarchy lives. Bones are entities, so the chain is walked here rather than on a
-     * skeleton object.
-     *
-     * @type {EntityComponentDataset}
-     */
-    dataset = null;
-
-    /**
-     * The bone being placed. Its ancestors are the rest of the chain, reached through
-     * {@link transform_attachment_parent_of}.
-     *
-     * @type {number}
-     */
-    effector = -1;
-
-    /**
-     *
-     * @type {Terrain}
-     */
-    terrain = null;
-
-    /**
-     * The clips playing on the constrained entity's model, with their times and weights: what a
-     * chain under a GPU-composed ancestor is evaluated against. Empty for a model nothing plays.
-     *
-     * @type {PosePlayback[]}
-     */
-    playbacks = [];
-
-    /**
-     * The system's per-tick evaluation cache, shared by every problem of the tick; null where a
-     * chain is evaluated on its own.
-     *
-     * @type {T64WorldCache|null}
-     */
-    cache = null;
-
-}
-
-/**
- *
- * @type {ObjectPoolFactory<IKProblem>}
- */
-IKProblem.pool = new ObjectPoolFactory(() => {
-    return new IKProblem();
-}, noop, noop);

package/src/engine/ecs/ik/IKSolver.d.ts

@@ -1,8 +0,0 @@
-export class IKSolver {
-    /**
-     *
-     * @param {IKProblem} problem
-     */
-    solve(problem: IKProblem): void;
-}
-//# sourceMappingURL=IKSolver.d.ts.map

package/src/engine/ecs/ik/IKSolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IKSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/IKSolver.js"],"names":[],"mappings":"AAAA;IACI;;;OAGG;IACH,gCAEC;CACJ"}

package/src/engine/ecs/ik/IKSolver.js

@@ -1,9 +0,0 @@
-export class IKSolver {
-    /**
-     *
-     * @param {IKProblem} problem
-     */
-    solve(problem) {
-        throw new Error('Not implemented');
-    }
-}

package/src/engine/ecs/ik/InverseKinematics.d.ts

@@ -1,48 +0,0 @@
-export class InverseKinematics {
-    /**
-     * @readonly
-     * @type {IKConstraint[]}
-     */
-    readonly constraints: IKConstraint[];
-    /**
-     *
-     * @param {InverseKinematics} other
-     */
-    copy(other: InverseKinematics): void;
-    clone(): InverseKinematics;
-    /**
-     *
-     * @param {Object} options
-     * @param {String} options.effector
-     * @param {number} options.offset
-     * @param {number} options.distanceMin
-     * @param {number} options.distanceMax
-     * @param {number} options.strength
-     * @param {number} options.limit
-     * @param {String} options.solver
-     */
-    add({ effector, offset, distanceMin, distanceMax, strength, limit, solver }: {
-        effector: string;
-        offset: number;
-        distanceMin: number;
-        distanceMax: number;
-        strength: number;
-        limit: number;
-        solver: string;
-    }): void;
-    /**
-     *
-     * @param {InverseKinematics} other
-     * @returns {boolean}
-     */
-    equals(other: InverseKinematics): boolean;
-    /**
-     * @returns {number}
-     */
-    hash(): number;
-}
-export namespace InverseKinematics {
-    let typeName: string;
-}
-import { IKConstraint } from "./IKConstraint.js";
-//# sourceMappingURL=InverseKinematics.d.ts.map

package/src/engine/ecs/ik/InverseKinematics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InverseKinematics.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/InverseKinematics.js"],"names":[],"mappings":"AAGA;IAEI;;;OAGG;IACH,sBAFU,YAAY,EAAE,CAEP;IAEjB;;;OAGG;IACH,YAFW,iBAAiB,QAe3B;IAED,2BAMC;IAED;;;;;;;;;;OAUG;IACH;QAR2B,QAAQ;QACR,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM;aAqBhC;IAED;;;;OAIG;IACH,cAHW,iBAAiB,GACf,OAAO,CAsBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAgBlB;CACJ;;;;6BAnH4B,mBAAmB"}

package/src/engine/ecs/ik/InverseKinematics.js

@@ -1,119 +0,0 @@
-import { IKConstraint } from "./IKConstraint.js";
-
-
-export class InverseKinematics {
-
-    /**
-     * @readonly
-     * @type {IKConstraint[]}
-     */
-    constraints = [];
-
-    /**
-     *
-     * @param {InverseKinematics} other
-     */
-    copy(other) {
-        this.constraints.splice(0, this.constraints.length);
-
-        const other_constraints = other.constraints;
-        const n = other_constraints.length;
-
-        for (let i = 0; i < n; i++) {
-            const constraint = other_constraints[i];
-
-            const constraintClone = constraint.clone();
-
-            this.constraints.push(constraintClone);
-        }
-    }
-
-    clone() {
-        const r = new InverseKinematics();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {Object} options
-     * @param {String} options.effector
-     * @param {number} options.offset
-     * @param {number} options.distanceMin
-     * @param {number} options.distanceMax
-     * @param {number} options.strength
-     * @param {number} options.limit
-     * @param {String} options.solver
-     */
-    add({
-            effector,
-            offset = 0,
-            distanceMin = 0,
-            distanceMax = 0.1,
-            strength = 1,
-            limit = Math.PI * 0.9,
-            solver = "2BIK"
-        }) {
-        const c = new IKConstraint();
-
-        c.effector = effector;
-        c.offset = offset;
-        c.strength = strength;
-        c.distance.set(distanceMin, distanceMax);
-        c.solver = solver;
-        c.limit = limit;
-
-        this.constraints.push(c);
-    }
-
-    /**
-     *
-     * @param {InverseKinematics} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        const cs0 = this.constraints;
-        const cs1 = other.constraints;
-
-        const n0 = cs0.length;
-        const n1 = cs1.length;
-
-        if (n0 !== n1) {
-            return false;
-        }
-
-        for (let i = 0; i < n0; i++) {
-            const c0 = cs0[i];
-            const c1 = cs1[i];
-            if (!c0.equals(c1)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * @returns {number}
-     */
-    hash() {
-
-        let hash = 0;
-        const constraints = this.constraints;
-        const length = constraints.length;
-
-        for (let i = 0; i < length; i++) {
-            const constraint = constraints[i];
-            const singleValue = constraint.hash();
-            hash = ((hash << 5) - hash) + singleValue;
-            hash |= 0; // Convert to 32bit integer
-        }
-
-        return hash;
-    }
-}
-
-InverseKinematics.typeName = "InverseKinematics";
-

package/src/engine/ecs/ik/InverseKinematicsSerializationAdapter.d.ts

@@ -1,19 +0,0 @@
-export class InverseKinematicsSerializationAdapter extends BinaryClassSerializationAdapter<any> {
-    constructor();
-    klass: typeof InverseKinematics;
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InverseKinematics} value
-     */
-    serialize(buffer: BinaryBuffer, value: InverseKinematics): void;
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InverseKinematics} value
-     */
-    deserialize(buffer: BinaryBuffer, value: InverseKinematics): void;
-}
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import { InverseKinematics } from "./InverseKinematics.js";
-//# sourceMappingURL=InverseKinematicsSerializationAdapter.d.ts.map

package/src/engine/ecs/ik/InverseKinematicsSerializationAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InverseKinematicsSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/InverseKinematicsSerializationAdapter.js"],"names":[],"mappings":"AAIA;;IAEI,gCAA0B;IAG1B;;;;OAIG;IACH,uCAFW,iBAAiB,QAqB3B;IAED;;;;OAIG;IACH,yCAFW,iBAAiB,QAgC3B;CACJ;gDAvE+C,sDAAsD;kCAEpE,wBAAwB"}

package/src/engine/ecs/ik/InverseKinematicsSerializationAdapter.js

@@ -1,72 +0,0 @@
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import { IKConstraint } from "./IKConstraint.js";
-import { InverseKinematics } from "./InverseKinematics.js";
-
-export class InverseKinematicsSerializationAdapter extends BinaryClassSerializationAdapter {
-
-    klass = InverseKinematics;
-    version = 0;
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InverseKinematics} value
-     */
-    serialize(buffer, value) {
-        const constraints = value.constraints;
-        const n = constraints.length;
-        buffer.writeUintVar(n);
-
-        for (let i = 0; i < n; i++) {
-            const constraint = constraints[i];
-
-            buffer.writeUTF8String(constraint.effector);
-
-            buffer.writeFloat32(constraint.offset);
-            buffer.writeFloat32(constraint.strength);
-            buffer.writeFloat32(constraint.limit);
-
-            buffer.writeFloat32(constraint.distance.min);
-            buffer.writeFloat32(constraint.distance.max);
-
-            buffer.writeUTF8String(constraint.solver);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {InverseKinematics} value
-     */
-    deserialize(buffer, value) {
-        const n = buffer.readUintVar();
-
-        const constraints = [];
-
-        for (let i = 0; i < n; i++) {
-            const effector = buffer.readUTF8String();
-
-            const offset = buffer.readFloat32();
-            const strength = buffer.readFloat32();
-            const limit = buffer.readFloat32();
-
-            const distanceMin = buffer.readFloat32();
-            const distanceMax = buffer.readFloat32();
-
-            const solver = buffer.readUTF8String();
-
-            const ikConstraint = new IKConstraint();
-
-            ikConstraint.effector = effector;
-            ikConstraint.offset = offset;
-            ikConstraint.strength = strength;
-            ikConstraint.limit = limit;
-            ikConstraint.distance.set(distanceMin, distanceMax);
-            ikConstraint.solver = solver;
-
-            constraints.push(ikConstraint);
-        }
-
-        value.constraints = constraints;
-    }
-}