@woosh/meep-engine/src/engine/ecs/ik/InverseKinematicsSerializationAdapter.js

Pure JavaScript game engine. Fully featured and production ready.

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;
    }
}