@polygonjs/polygonjs/dist/src/engine/nodes/js/code/assemblers/_BaseJsPersistedConfigUtils.js

node-based WebGL 3D engine https://polygonjs.com

"use strict";
import {
  Box3,
  Color,
  Vector2,
  Vector3,
  Vector4,
  Plane,
  Ray,
  Sphere,
  Quaternion,
  Matrix4,
  Euler
} from "three";
import { isBoolean, isNumber, isString } from "../../../../../core/Type";
import { TypeAssert } from "../../../../poly/Assert";
import {
  JsConnectionPointType,
  JsConnectionPointTypeFromArrayTypeMap
} from "../../../utils/io/connections/Js";
export class PrimitiveArray {
  constructor(_elements) {
    this._elements = _elements;
    this.isPrimitiveArray = true;
  }
  elements() {
    return this._elements;
  }
  clone() {
    return this._elements.map((v) => v);
  }
}
export class VectorArray {
  constructor(_elements) {
    this._elements = _elements;
    this.isVectorArray = true;
  }
  elements() {
    return this._elements;
  }
  clone() {
    return this._elements.map((v) => v.clone());
  }
}
export function createVariable(type) {
  switch (type) {
    case JsConnectionPointType.BOOLEAN:
    case JsConnectionPointType.INT:
    case JsConnectionPointType.FLOAT:
    case JsConnectionPointType.STRING: {
      return null;
    }
    case JsConnectionPointType.COLOR: {
      return new Color();
    }
    case JsConnectionPointType.EULER: {
      return new Euler();
    }
    case JsConnectionPointType.MATRIX4: {
      return new Matrix4();
    }
    case JsConnectionPointType.QUATERNION: {
      return new Quaternion();
    }
    case JsConnectionPointType.VECTOR2: {
      return new Vector2();
    }
    case JsConnectionPointType.VECTOR3: {
      return new Vector3();
    }
    case JsConnectionPointType.VECTOR4: {
      return new Vector4();
    }
    case JsConnectionPointType.BOX3: {
      return new Box3();
    }
    case JsConnectionPointType.PLANE: {
      return new Plane();
    }
    case JsConnectionPointType.RAY: {
      return new Ray();
    }
    case JsConnectionPointType.SPHERE: {
      return new Sphere();
    }
    case JsConnectionPointType.BOOLEAN_ARRAY:
    case JsConnectionPointType.FLOAT_ARRAY:
    case JsConnectionPointType.INT_ARRAY:
    case JsConnectionPointType.STRING_ARRAY: {
      return createPrimitiveArray(type);
    }
    case JsConnectionPointType.MATRIX4_ARRAY:
    case JsConnectionPointType.QUATERNION_ARRAY:
    case JsConnectionPointType.TEXTURE_ARRAY:
    case JsConnectionPointType.COLOR_ARRAY:
    case JsConnectionPointType.EULER_ARRAY:
    case JsConnectionPointType.OBJECT_3D_ARRAY:
    case JsConnectionPointType.VECTOR2_ARRAY:
    case JsConnectionPointType.VECTOR3_ARRAY:
    case JsConnectionPointType.VECTOR4_ARRAY: {
      return createVectorArray(type);
    }
    case JsConnectionPointType.ANIMATION_MIXER:
    case JsConnectionPointType.ANIMATION_ACTION:
    case JsConnectionPointType.CAMERA:
    case JsConnectionPointType.CATMULL_ROM_CURVE3:
    case JsConnectionPointType.INTERSECTION:
    case JsConnectionPointType.INTERSECTION_ARRAY:
    case JsConnectionPointType.MATERIAL:
    case JsConnectionPointType.NODE:
    case JsConnectionPointType.OBJECT_3D:
    case JsConnectionPointType.PARAM:
    case JsConnectionPointType.TEXTURE:
    case JsConnectionPointType.TEXTURE_ARRAY:
    case JsConnectionPointType.TRIGGER: {
      return null;
    }
  }
  console.warn("createVariable not implemented with type", type);
  TypeAssert.unreachable(type);
}
export function createPrimitiveArray(type) {
  type = JsConnectionPointTypeFromArrayTypeMap[type];
  switch (type) {
    case JsConnectionPointType.BOOLEAN: {
      return new PrimitiveArray([false]);
    }
    case JsConnectionPointType.INT: {
      return new PrimitiveArray([0]);
    }
    case JsConnectionPointType.FLOAT: {
      return new PrimitiveArray([0]);
    }
    case JsConnectionPointType.STRING: {
      return new PrimitiveArray([""]);
    }
  }
  console.warn("createPrimitiveArray not implemented for type:", type);
  return new PrimitiveArray([0]);
}
export function createVectorArray(type) {
  type = JsConnectionPointTypeFromArrayTypeMap[type];
  switch (type) {
    case JsConnectionPointType.COLOR: {
      return new VectorArray([new Color()]);
    }
    case JsConnectionPointType.EULER: {
      return new VectorArray([new Euler()]);
    }
    case JsConnectionPointType.MATRIX4: {
      return new VectorArray([new Matrix4()]);
    }
    case JsConnectionPointType.QUATERNION: {
      return new VectorArray([new Quaternion()]);
    }
    case JsConnectionPointType.VECTOR2: {
      return new VectorArray([new Vector2()]);
    }
    case JsConnectionPointType.VECTOR3: {
      return new VectorArray([new Vector3()]);
    }
    case JsConnectionPointType.VECTOR4: {
      return new VectorArray([new Vector4()]);
    }
  }
  console.warn("createVectorArray not implemented for type:", type);
  return new VectorArray([new Vector4()]);
}
export var SerializedVariableType = /* @__PURE__ */ ((SerializedVariableType2) => {
  SerializedVariableType2["Box3"] = "Box3";
  SerializedVariableType2["Color"] = "Color";
  SerializedVariableType2["Euler"] = "Euler";
  SerializedVariableType2["Matrix4"] = "Matrix4";
  SerializedVariableType2["Plane"] = "Plane";
  SerializedVariableType2["Quaternion"] = "Quaternion";
  SerializedVariableType2["Ray"] = "Ray";
  SerializedVariableType2["Sphere"] = "Sphere";
  SerializedVariableType2["Vector2"] = "Vector2";
  SerializedVariableType2["Vector3"] = "Vector3";
  SerializedVariableType2["Vector4"] = "Vector4";
  SerializedVariableType2["boolean_Array"] = "boolean[]";
  SerializedVariableType2["number_Array"] = "number[]";
  SerializedVariableType2["string_Array"] = "string[]";
  SerializedVariableType2["Color_Array"] = "Color[]";
  SerializedVariableType2["Euler_Array"] = "Euler[]";
  SerializedVariableType2["Matrix4_Array"] = "Matrix4[]";
  SerializedVariableType2["Quaternion_Array"] = "Quaternion[]";
  SerializedVariableType2["Vector2_Array"] = "Vector2[]";
  SerializedVariableType2["Vector3_Array"] = "Vector3[]";
  SerializedVariableType2["Vector4_Array"] = "Vector4[]";
  return SerializedVariableType2;
})(SerializedVariableType || {});
export function isVariableSerializable(variable) {
  if (variable instanceof Box3 || variable instanceof Color || variable instanceof Euler || variable instanceof Matrix4 || variable instanceof Plane || variable instanceof Quaternion || variable instanceof Ray || variable instanceof Sphere || variable instanceof Vector2 || variable instanceof Vector3 || variable instanceof Vector4 || variable instanceof PrimitiveArray || variable instanceof VectorArray) {
    return true;
  } else {
    console.warn("not serializable", variable);
    return false;
  }
}
export function serializeVariable(variable) {
  if (variable instanceof Box3) {
    const data2 = {
      type: "Box3" /* Box3 */,
      data: {
        min: variable.min.toArray(),
        max: variable.min.toArray()
      }
    };
    return data2;
  }
  if (variable instanceof Color) {
    const data2 = {
      type: "Color" /* Color */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable instanceof Euler) {
    const data2 = {
      type: "Euler" /* Euler */,
      data: {
        rotation: variable.toArray(),
        rotationOrder: variable.order
      }
    };
    return data2;
  }
  if (variable instanceof Matrix4) {
    const data2 = {
      type: "Matrix4" /* Matrix4 */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable instanceof Plane) {
    const data2 = {
      type: "Plane" /* Plane */,
      data: {
        normal: variable.normal.toArray(),
        constant: variable.constant
      }
    };
    return data2;
  }
  if (variable instanceof Quaternion) {
    const data2 = {
      type: "Quaternion" /* Quaternion */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable instanceof Ray) {
    const data2 = {
      type: "Ray" /* Ray */,
      data: {
        origin: variable.origin.toArray(),
        direction: variable.direction.toArray()
      }
    };
    return data2;
  }
  if (variable instanceof Sphere) {
    const data2 = {
      type: "Sphere" /* Sphere */,
      data: {
        center: variable.center.toArray(),
        radius: variable.radius
      }
    };
    return data2;
  }
  if (variable instanceof Vector2) {
    const data2 = {
      type: "Vector2" /* Vector2 */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable instanceof Vector3) {
    const data2 = {
      type: "Vector3" /* Vector3 */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable instanceof Vector4) {
    const data2 = {
      type: "Vector4" /* Vector4 */,
      data: variable.toArray()
    };
    return data2;
  }
  if (variable.isPrimitiveArray) {
    const elements = variable.elements();
    const firstElement = elements[0];
    if (isBoolean(firstElement)) {
      const data2 = {
        type: "boolean[]" /* boolean_Array */,
        data: elements.map((v) => v)
      };
      return data2;
    }
    if (isNumber(firstElement)) {
      const data2 = {
        type: "number[]" /* number_Array */,
        data: elements.map((v) => v)
      };
      return data2;
    }
    if (isString(firstElement)) {
      const data2 = {
        type: "string[]" /* string_Array */,
        data: elements.map((v) => v)
      };
      return data2;
    }
  }
  if (variable.isVectorArray) {
    const elements = variable.elements();
    const firstElement = elements[0];
    if (firstElement instanceof Color) {
      const data2 = {
        type: "Color[]" /* Color_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    if (firstElement instanceof Euler) {
      const data2 = {
        type: "Euler[]" /* Euler_Array */,
        data: elements.map((v) => ({
          rotation: v.toArray(),
          rotationOrder: v.order
        }))
      };
      return data2;
    }
    if (firstElement instanceof Matrix4) {
      const data2 = {
        type: "Matrix4[]" /* Matrix4_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    if (firstElement instanceof Quaternion) {
      const data2 = {
        type: "Quaternion[]" /* Quaternion_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    if (firstElement instanceof Vector2) {
      const data2 = {
        type: "Vector2[]" /* Vector2_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    if (firstElement instanceof Vector3) {
      const data2 = {
        type: "Vector3[]" /* Vector3_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    if (firstElement instanceof Vector4) {
      const data2 = {
        type: "Vector4[]" /* Vector4_Array */,
        data: elements.map((v) => v.toArray())
      };
      return data2;
    }
    console.log("array variable serialization not implemeted", variable, firstElement);
  }
  console.log("variable serialization not implemeted", variable);
  const data = {
    type: "Vector3" /* Vector3 */,
    data: new Vector3().toArray()
  };
  return data;
}
export function deserializeVariable(serialized) {
  const type = serialized.type;
  switch (type) {
    case "Box3" /* Box3 */: {
      const data = serialized.data;
      const box3 = new Box3();
      box3.min.set(data.min[0], data.min[1], data.min[2]);
      box3.max.set(data.max[0], data.max[1], data.max[2]);
      return box3;
    }
    case "Color" /* Color */: {
      const data = serialized.data;
      const color = new Color();
      color.r = data[0];
      color.g = data[1];
      color.b = data[2];
      return color;
    }
    case "Euler" /* Euler */: {
      const data = serialized.data;
      const euler = new Euler(data.rotation[0], data.rotation[1], data.rotation[2], data.rotationOrder);
      return euler;
    }
    case "Matrix4" /* Matrix4 */: {
      const data = serialized.data;
      const matrix = new Matrix4();
      matrix.set(...data);
      return matrix;
    }
    case "Plane" /* Plane */: {
      const data = serialized.data;
      const plane = new Plane();
      plane.normal.set(...data.normal);
      plane.constant = data.constant;
      return plane;
    }
    case "Quaternion" /* Quaternion */: {
      const data = serialized.data;
      const vector = new Quaternion();
      vector.set(...data);
      return vector;
    }
    case "Ray" /* Ray */: {
      const data = serialized.data;
      const ray = new Ray();
      ray.origin.set(...data.origin);
      ray.direction.set(...data.direction);
      return ray;
    }
    case "Sphere" /* Sphere */: {
      const data = serialized.data;
      const sphere = new Sphere();
      sphere.center.set(...data.center);
      sphere.radius = data.radius;
      return sphere;
    }
    case "Vector2" /* Vector2 */: {
      const data = serialized.data;
      const vector = new Vector2();
      vector.set(...data);
      return vector;
    }
    case "Vector3" /* Vector3 */: {
      const data = serialized.data;
      const vector = new Vector3();
      vector.set(...data);
      return vector;
    }
    case "Vector4" /* Vector4 */: {
      const data = serialized.data;
      const vector = new Vector4();
      vector.set(...data);
      return vector;
    }
    case "boolean[]" /* boolean_Array */: {
      const data = serialized.data;
      const values = [...data];
      const numberArray = new PrimitiveArray(values);
      return numberArray;
    }
    case "number[]" /* number_Array */: {
      const data = serialized.data;
      const values = [...data];
      const numberArray = new PrimitiveArray(values);
      return numberArray;
    }
    case "string[]" /* string_Array */: {
      const data = serialized.data;
      const values = [...data];
      const numberArray = new PrimitiveArray(values);
      return numberArray;
    }
    case "Color[]" /* Color_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const color = new Color();
        color.r = d[0];
        color.g = d[1];
        color.b = d[2];
        return color;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
    case "Euler[]" /* Euler_Array */: {
      const data = serialized.data;
      const eulers = data.map((d) => {
        const euler = new Euler(d.rotation[0], d.rotation[1], d.rotation[2], d.rotationOrder);
        return euler;
      });
      const vectorArray = new VectorArray(eulers);
      return vectorArray;
    }
    case "Matrix4[]" /* Matrix4_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const v = new Matrix4();
        v.set(...d);
        return v;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
    case "Quaternion[]" /* Quaternion_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const v = new Quaternion();
        v.set(...d);
        return v;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
    case "Vector2[]" /* Vector2_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const v = new Vector2();
        v.set(...d);
        return v;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
    case "Vector3[]" /* Vector3_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const v = new Vector3();
        v.set(...d);
        return v;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
    case "Vector4[]" /* Vector4_Array */: {
      const data = serialized.data;
      const vectors = data.map((d) => {
        const v = new Vector4();
        v.set(...d);
        return v;
      });
      const vectorArray = new VectorArray(vectors);
      return vectorArray;
    }
  }
  TypeAssert.unreachable(type);
}