wonder.js/lib/js/src/api/TransformAPI.js

3d webgl engine

'use strict';

var Caml_option = require("bs-platform/lib/js/caml_option.js");
var Js_null_undefined = require("bs-platform/lib/js/js_null_undefined.js");
var Contract$WonderLog = require("wonder-log/lib/js/src/Contract.js");
var StateDataMain$Wonderjs = require("../service/state/main/data/StateDataMain.js");
var IsDebugMainService$Wonderjs = require("../service/state/main/state/IsDebugMainService.js");
var AliveComponentService$Wonderjs = require("../service/primitive/component/AliveComponentService.js");
var HierachyTransformService$Wonderjs = require("../service/record/main/transform/HierachyTransformService.js");
var CreateTransformMainService$Wonderjs = require("../service/state/main/transform/CreateTransformMainService.js");
var GameObjectTransformService$Wonderjs = require("../service/record/main/transform/GameObjectTransformService.js");
var LookAtTransfromMainService$Wonderjs = require("../service/state/main/transform/LookAtTransfromMainService.js");
var RecordTransformMainService$Wonderjs = require("../service/state/main/transform/RecordTransformMainService.js");
var RotateTransformMainService$Wonderjs = require("../service/state/main/transform/RotateTransformMainService.js");
var UpdateTransformMainService$Wonderjs = require("../service/state/main/transform/UpdateTransformMainService.js");
var DisposeTransformMainService$Wonderjs = require("../service/state/main/transform/DisposeTransformMainService.js");
var ModelMatrixTransformService$Wonderjs = require("../service/record/main/transform/ModelMatrixTransformService.js");
var HierachyTransformMainService$Wonderjs = require("../service/state/main/transform/HierachyTransformMainService.js");

function createTransform(state) {
  return CreateTransformMainService$Wonderjs.create(state);
}

function unsafeGetTransformGameObject(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GameObjectTransformService$Wonderjs.unsafeGetGameObject(transform, RecordTransformMainService$Wonderjs.getRecord(state));
}

function unsafeGetTransformParent(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HierachyTransformService$Wonderjs.unsafeGetParent(transform, RecordTransformMainService$Wonderjs.getRecord(state));
}

function hasTransformParent(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HierachyTransformService$Wonderjs.hasParent(transform, RecordTransformMainService$Wonderjs.getRecord(state));
}

function _checkParentAndChildTransformShouldAlive(parent, child, state) {
  return Contract$WonderLog.requireCheck((function (param) {
                Js_null_undefined.iter(parent, (function (parent) {
                        return AliveComponentService$Wonderjs.checkComponentShouldAlive(parent, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
                      }));
                return AliveComponentService$Wonderjs.checkComponentShouldAlive(child, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
              }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
}

function _setTransformParent(parent, child, setParentFunc, state) {
  _checkParentAndChildTransformShouldAlive(parent, child, state);
  state[/* transformRecord */11] = setParentFunc((parent == null) ? undefined : Caml_option.some(parent), child, RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function setTransformParent(parent, child, state) {
  return _setTransformParent(parent, child, HierachyTransformService$Wonderjs.setParent, state);
}

function setTransformParentKeepOrder(parent, child, state) {
  return _setTransformParent(parent, child, HierachyTransformService$Wonderjs.setParentKeepOrder, state);
}

function unsafeGetTransformChildren(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HierachyTransformService$Wonderjs.unsafeGetChildren(transform, RecordTransformMainService$Wonderjs.getRecord(state));
}

function getTransformLocalPosition(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return ModelMatrixTransformService$Wonderjs.getLocalPositionTuple(transform, RecordTransformMainService$Wonderjs.getRecord(state)[/* localPositions */3]);
}

function setTransformLocalPosition(transform, localPosition, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = ModelMatrixTransformService$Wonderjs.setLocalPositionByTuple(transform, localPosition, RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformPosition(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return UpdateTransformMainService$Wonderjs.updateAndGetPositionTuple(transform, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
}

function setTransformPosition(transform, position, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = UpdateTransformMainService$Wonderjs.updateAndSetPositionByTuple(transform, position, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformLocalRotation(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return ModelMatrixTransformService$Wonderjs.getLocalRotationTuple(transform, RecordTransformMainService$Wonderjs.getRecord(state)[/* localRotations */4]);
}

function setTransformLocalRotation(transform, localRotation, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = ModelMatrixTransformService$Wonderjs.setLocalRotationByTuple(transform, localRotation, RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformRotation(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return UpdateTransformMainService$Wonderjs.updateAndGetRotationTuple(transform, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
}

function setTransformRotation(transform, rotation, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = UpdateTransformMainService$Wonderjs.updateAndSetRotationByTuple(transform, rotation, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformLocalScale(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return ModelMatrixTransformService$Wonderjs.getLocalScaleTuple(transform, RecordTransformMainService$Wonderjs.getRecord(state)[/* localScales */5]);
}

function setTransformLocalScale(transform, localScale, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = ModelMatrixTransformService$Wonderjs.setLocalScaleByTuple(transform, localScale, RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformScale(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return UpdateTransformMainService$Wonderjs.updateAndGetScaleTuple(transform, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
}

function setTransformScale(transform, scale, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = UpdateTransformMainService$Wonderjs.updateAndSetScaleByTuple(transform, scale, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformLocalEulerAngles(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return ModelMatrixTransformService$Wonderjs.getLocalEulerAnglesTuple(transform, RecordTransformMainService$Wonderjs.getRecord(state)[/* localRotations */4]);
}

function setTransformLocalEulerAngles(transform, eulerAngles, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = ModelMatrixTransformService$Wonderjs.setLocalEulerAnglesByTuple(transform, eulerAngles, RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function getTransformEulerAngles(transform, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return UpdateTransformMainService$Wonderjs.updateAndGetEulerAnglesTuple(transform, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
}

function setTransformEulerAngles(transform, eulerAngles, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  state[/* transformRecord */11] = UpdateTransformMainService$Wonderjs.updateAndSetEulerAnglesByTuple(transform, eulerAngles, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
  return state;
}

function lookAt(transform, target, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return LookAtTransfromMainService$Wonderjs.lookAt(transform, target, state, undefined, /* () */0);
}

function lookAtWithUp(transform, target, up, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return LookAtTransfromMainService$Wonderjs.lookAt(transform, target, state, up, /* () */0);
}

function getTransformLocalToWorldMatrixTypeArray(transform, state) {
  return UpdateTransformMainService$Wonderjs.updateAndGetLocalToWorldMatrixTypeArray(transform, state[/* globalTempRecord */37], RecordTransformMainService$Wonderjs.getRecord(state));
}

function rotateLocalOnAxis(transform, param, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return RotateTransformMainService$Wonderjs.rotateLocalOnAxis(transform, /* tuple */[
              param[0],
              param[1]
            ], state);
}

function rotateWorldOnAxis(transform, param, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return AliveComponentService$Wonderjs.checkComponentShouldAlive(transform, DisposeTransformMainService$Wonderjs.isAlive, RecordTransformMainService$Wonderjs.getRecord(state));
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return RotateTransformMainService$Wonderjs.rotateWorldOnAxis(transform, /* tuple */[
              param[0],
              param[1]
            ], state);
}

var changeChildOrder = HierachyTransformMainService$Wonderjs.changeChildOrder;

exports.createTransform = createTransform;
exports.unsafeGetTransformGameObject = unsafeGetTransformGameObject;
exports.unsafeGetTransformParent = unsafeGetTransformParent;
exports.hasTransformParent = hasTransformParent;
exports._checkParentAndChildTransformShouldAlive = _checkParentAndChildTransformShouldAlive;
exports._setTransformParent = _setTransformParent;
exports.setTransformParent = setTransformParent;
exports.setTransformParentKeepOrder = setTransformParentKeepOrder;
exports.unsafeGetTransformChildren = unsafeGetTransformChildren;
exports.getTransformLocalPosition = getTransformLocalPosition;
exports.setTransformLocalPosition = setTransformLocalPosition;
exports.getTransformPosition = getTransformPosition;
exports.setTransformPosition = setTransformPosition;
exports.getTransformLocalRotation = getTransformLocalRotation;
exports.setTransformLocalRotation = setTransformLocalRotation;
exports.getTransformRotation = getTransformRotation;
exports.setTransformRotation = setTransformRotation;
exports.getTransformLocalScale = getTransformLocalScale;
exports.setTransformLocalScale = setTransformLocalScale;
exports.getTransformScale = getTransformScale;
exports.setTransformScale = setTransformScale;
exports.getTransformLocalEulerAngles = getTransformLocalEulerAngles;
exports.setTransformLocalEulerAngles = setTransformLocalEulerAngles;
exports.getTransformEulerAngles = getTransformEulerAngles;
exports.setTransformEulerAngles = setTransformEulerAngles;
exports.lookAt = lookAt;
exports.lookAtWithUp = lookAtWithUp;
exports.getTransformLocalToWorldMatrixTypeArray = getTransformLocalToWorldMatrixTypeArray;
exports.rotateLocalOnAxis = rotateLocalOnAxis;
exports.rotateWorldOnAxis = rotateWorldOnAxis;
exports.changeChildOrder = changeChildOrder;
/* Contract-WonderLog Not a pure module */