wonder.js/lib/js/src/api/GameObjectAPI.js

3d webgl engine

'use strict';

var Log$WonderLog = require("wonder-log/lib/js/src/Log.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 ArrayService$WonderCommonlib = require("wonder-commonlib/lib/js/src/ArrayService.js");
var AllGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/AllGameObjectMainService.js");
var InitGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/InitGameObjectMainService.js");
var NameGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/NameGameObjectMainService.js");
var AliveGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/AliveGameObjectMainService.js");
var CloneGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/CloneGameObjectMainService.js");
var CreateGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/CreateGameObjectMainService.js");
var IsRootGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/IsRootGameObjectMainService.js");
var DisposeGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/DisposeGameObjectMainService.js");
var GetComponentGameObjectService$Wonderjs = require("../service/record/main/gameObject/GetComponentGameObjectService.js");
var HasComponentGameObjectService$Wonderjs = require("../service/record/main/gameObject/HasComponentGameObjectService.js");
var GetIsActiveGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/GetIsActiveGameObjectMainService.js");
var SetIsActiveGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/SetIsActiveGameObjectMainService.js");
var AddComponentGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/AddComponentGameObjectMainService.js");
var GetComponentGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/GetComponentGameObjectMainService.js");
var RemoveComponentGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/RemoveComponentGameObjectMainService.js");
var DisposeComponentGameObjectMainService$Wonderjs = require("../service/state/main/gameObject/DisposeComponentGameObjectMainService.js");

var createGameObject = CreateGameObjectMainService$Wonderjs.create;

function _checkGameObjectShouldAlive(gameObject, state) {
  return Contract$WonderLog.test(Log$WonderLog.buildAssertMessage("gameObject alive", "not"), (function (param) {
                return Contract$WonderLog.assertTrue(AliveGameObjectMainService$Wonderjs.isAlive(gameObject, state));
              }));
}

function addGameObjectScriptComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addScriptComponent(gameObject, component, state);
}

function disposeGameObjectScriptComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeScriptComponent(gameObject, component, state);
}

function unsafeGetGameObjectScriptComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetScriptComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectScriptComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasScriptComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectBasicCameraViewComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addBasicCameraViewComponent(gameObject, component, state);
}

function disposeGameObjectBasicCameraViewComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeBasicCameraViewComponent(gameObject, component, state);
}

function unsafeGetGameObjectBasicCameraViewComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetBasicCameraViewComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectBasicCameraViewComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasBasicCameraViewComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectPerspectiveCameraProjectionComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addPerspectiveCameraProjectionComponent(gameObject, component, state);
}

function disposeGameObjectPerspectiveCameraProjectionComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposePerspectiveCameraProjectionComponent(gameObject, component, state);
}

function unsafeGetGameObjectPerspectiveCameraProjectionComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetPerspectiveCameraProjectionComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectPerspectiveCameraProjectionComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasPerspectiveCameraProjectionComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectFlyCameraControllerComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addFlyCameraControllerComponent(gameObject, component, state);
}

function disposeGameObjectFlyCameraControllerComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeFlyCameraControllerComponent(gameObject, component, state);
}

function unsafeGetGameObjectFlyCameraControllerComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetFlyCameraControllerComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectFlyCameraControllerComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasFlyCameraControllerComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectArcballCameraControllerComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addArcballCameraControllerComponent(gameObject, component, state);
}

function disposeGameObjectArcballCameraControllerComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeArcballCameraControllerComponent(gameObject, component, state);
}

function unsafeGetGameObjectArcballCameraControllerComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetArcballCameraControllerComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectArcballCameraControllerComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasArcballCameraControllerComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectTransformComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addTransformComponent(gameObject, component, state);
}

function disposeGameObjectTransformComponent(gameObject, component, isKeepOrder, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  if (isKeepOrder) {
    return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeTransformComponentForKeepOrder(gameObject, component, state);
  } else {
    return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeTransformComponent(gameObject, component, state);
  }
}

function unsafeGetGameObjectTransformComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetTransformComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectTransformComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasTransformComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectGeometryComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addGeometryComponent(gameObject, component, state);
}

function disposeGameObjectGeometryComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeGeometryComponent(gameObject, component, state);
}

function removeGameObjectGeometryComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return RemoveComponentGameObjectMainService$Wonderjs.removeGeometryComponent(gameObject, component, state);
}

function removeGameObjectBasicMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return RemoveComponentGameObjectMainService$Wonderjs.removeBasicMaterialComponent(gameObject, component, state);
}

function removeGameObjectLightMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return RemoveComponentGameObjectMainService$Wonderjs.removeLightMaterialComponent(gameObject, component, state);
}

function unsafeGetGameObjectGeometryComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetGeometryComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectGeometryComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasGeometryComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectBasicMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addBasicMaterialComponent(gameObject, component, state);
}

function disposeGameObjectBasicMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeBasicMaterialComponent(gameObject, component, state);
}

function unsafeGetGameObjectBasicMaterialComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetBasicMaterialComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectBasicMaterialComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasBasicMaterialComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectLightMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addLightMaterialComponent(gameObject, component, state);
}

function disposeGameObjectLightMaterialComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeLightMaterialComponent(gameObject, component, state);
}

function disposeGameObjectLightMaterialComponentRemoveTexture(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeLightMaterialComponentRemoveTexture(gameObject, component, state);
}

function unsafeGetGameObjectLightMaterialComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetLightMaterialComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectLightMaterialComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasLightMaterialComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectMeshRendererComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addMeshRendererComponent(gameObject, component, state);
}

function disposeGameObjectMeshRendererComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeMeshRendererComponent(gameObject, component, state);
}

function unsafeGetGameObjectMeshRendererComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetMeshRendererComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectMeshRendererComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasMeshRendererComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectDirectionLightComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addDirectionLightComponent(gameObject, component, state);
}

function disposeGameObjectDirectionLightComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeDirectionLightComponent(gameObject, component, state);
}

function unsafeGetGameObjectDirectionLightComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetDirectionLightComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectDirectionLightComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasDirectionLightComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectPointLightComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addPointLightComponent(gameObject, component, state);
}

function disposeGameObjectPointLightComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposePointLightComponent(gameObject, component, state);
}

function unsafeGetGameObjectPointLightComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetPointLightComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectPointLightComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasPointLightComponent(gameObject, state[/* gameObjectRecord */10]);
}

function addGameObjectSourceInstanceComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addSourceInstanceComponent(gameObject, component, state);
}

function unsafeGetGameObjectSourceInstanceComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetSourceInstanceComponent(gameObject, state[/* gameObjectRecord */10]);
}

function hasGameObjectSourceInstanceComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return HasComponentGameObjectService$Wonderjs.hasSourceInstanceComponent(gameObject, state[/* gameObjectRecord */10]);
}

function disposeGameObjectSourceInstanceComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeSourceInstanceComponent(gameObject, component, state);
}

function addGameObjectObjectInstanceComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AddComponentGameObjectMainService$Wonderjs.addObjectInstanceComponent(gameObject, component, state);
}

function unsafeGetGameObjectObjectInstanceComponent(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetComponentGameObjectService$Wonderjs.unsafeGetObjectInstanceComponent(gameObject, state[/* gameObjectRecord */10]);
}

function disposeGameObjectObjectInstanceComponent(gameObject, component, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeComponentGameObjectMainService$Wonderjs.deferDisposeObjectInstanceComponent(gameObject, component, state);
}

var isGameObjectAlive = AliveGameObjectMainService$Wonderjs.isAlive;

function disposeGameObject(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDispose(gameObject, state);
}

function disposeGameObjectKeepOrder(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDisposeKeepOrder(gameObject, state);
}

function disposeGameObjectKeepOrderRemoveGeometry(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDisposeKeepOrderRemoveGeometry(gameObject, state);
}

function disposeGameObjectKeepOrderRemoveGeometryRemoveMaterial(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDisposeKeepOrderRemoveGeometryRemoveMaterial(gameObject, state);
}

function disposeGameObjectDisposeGeometryRemoveMaterial(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDisposeDisposeGeometryRemoveMaterial(gameObject, state);
}

function disposeGameObjectRemoveTexture(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferDisposeRemoveTexture(gameObject, state);
}

function initGameObject(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return InitGameObjectMainService$Wonderjs.initGameObject(gameObject, state);
}

function batchDisposeGameObject(gameObjectArray, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return ArrayService$WonderCommonlib.forEach((function (gameObject) {
                        return _checkGameObjectShouldAlive(gameObject, state);
                      }), gameObjectArray);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferBatchDispose(gameObjectArray, state);
}

function batchDisposeGameObjectKeepOrder(gameObjectArray, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return ArrayService$WonderCommonlib.forEach((function (gameObject) {
                        return _checkGameObjectShouldAlive(gameObject, state);
                      }), gameObjectArray);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return DisposeGameObjectMainService$Wonderjs.deferBatchDisposeKeepOrder(gameObjectArray, state);
}

var cloneGameObject = CloneGameObjectMainService$Wonderjs.clone;

function getGameObjectName(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return NameGameObjectMainService$Wonderjs.getName(gameObject, state);
}

function unsafeGetGameObjectName(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return NameGameObjectMainService$Wonderjs.unsafeGetName(gameObject, state);
}

function setGameObjectName(gameObject, name, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return NameGameObjectMainService$Wonderjs.setName(gameObject, name, state);
}

function unsafeGetGameObjectIsRoot(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return IsRootGameObjectMainService$Wonderjs.unsafeGetIsRoot(gameObject, state);
}

function setGameObjectIsRoot(gameObject, isRoot, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return IsRootGameObjectMainService$Wonderjs.setIsRoot(gameObject, isRoot, state);
}

function getAllChildrenTransform(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AllGameObjectMainService$Wonderjs.getAllChildrenTransform(gameObject, state);
}

function getAllGameObjects(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return AllGameObjectMainService$Wonderjs.getAllGameObjects(gameObject, state);
}

function unsafeGetGameObjectIsActive(gameObject, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return GetIsActiveGameObjectMainService$Wonderjs.unsafeGetIsActive(gameObject, state);
}

function setGameObjectIsActive(gameObject, isScriptActive, state) {
  Contract$WonderLog.requireCheck((function (param) {
          return _checkGameObjectShouldAlive(gameObject, state);
        }), IsDebugMainService$Wonderjs.getIsDebug(StateDataMain$Wonderjs.stateData));
  return SetIsActiveGameObjectMainService$Wonderjs.setIsActive(gameObject, isScriptActive, state);
}

var getAllDirectionLightComponentsOfGameObject = AllGameObjectMainService$Wonderjs.getAllDirectionLightComponentsOfGameObject;

var getAllPointLightComponentsOfGameObject = AllGameObjectMainService$Wonderjs.getAllPointLightComponentsOfGameObject;

var getAllGeometryComponents = GetComponentGameObjectMainService$Wonderjs.getAllGeometryComponents;

var getAllFlyCameraControllerComponents = GetComponentGameObjectMainService$Wonderjs.getAllFlyCameraControllerComponents;

var getAllArcballCameraControllerComponents = GetComponentGameObjectMainService$Wonderjs.getAllArcballCameraControllerComponents;

var getAllBasicCameraViewComponents = GetComponentGameObjectMainService$Wonderjs.getAllBasicCameraViewComponents;

var getAllPerspectiveCameraProjectionComponents = GetComponentGameObjectMainService$Wonderjs.getAllPerspectiveCameraProjectionComponents;

var getAllBasicMaterialComponents = GetComponentGameObjectMainService$Wonderjs.getAllBasicMaterialComponents;

var getAllLightMaterialComponents = GetComponentGameObjectMainService$Wonderjs.getAllLightMaterialComponents;

var getAllDirectionLightComponents = GetComponentGameObjectMainService$Wonderjs.getAllDirectionLightComponents;

var getAllPointLightComponents = GetComponentGameObjectMainService$Wonderjs.getAllPointLightComponents;

exports.createGameObject = createGameObject;
exports._checkGameObjectShouldAlive = _checkGameObjectShouldAlive;
exports.addGameObjectScriptComponent = addGameObjectScriptComponent;
exports.disposeGameObjectScriptComponent = disposeGameObjectScriptComponent;
exports.unsafeGetGameObjectScriptComponent = unsafeGetGameObjectScriptComponent;
exports.hasGameObjectScriptComponent = hasGameObjectScriptComponent;
exports.addGameObjectBasicCameraViewComponent = addGameObjectBasicCameraViewComponent;
exports.disposeGameObjectBasicCameraViewComponent = disposeGameObjectBasicCameraViewComponent;
exports.unsafeGetGameObjectBasicCameraViewComponent = unsafeGetGameObjectBasicCameraViewComponent;
exports.hasGameObjectBasicCameraViewComponent = hasGameObjectBasicCameraViewComponent;
exports.addGameObjectPerspectiveCameraProjectionComponent = addGameObjectPerspectiveCameraProjectionComponent;
exports.disposeGameObjectPerspectiveCameraProjectionComponent = disposeGameObjectPerspectiveCameraProjectionComponent;
exports.unsafeGetGameObjectPerspectiveCameraProjectionComponent = unsafeGetGameObjectPerspectiveCameraProjectionComponent;
exports.hasGameObjectPerspectiveCameraProjectionComponent = hasGameObjectPerspectiveCameraProjectionComponent;
exports.addGameObjectFlyCameraControllerComponent = addGameObjectFlyCameraControllerComponent;
exports.disposeGameObjectFlyCameraControllerComponent = disposeGameObjectFlyCameraControllerComponent;
exports.unsafeGetGameObjectFlyCameraControllerComponent = unsafeGetGameObjectFlyCameraControllerComponent;
exports.hasGameObjectFlyCameraControllerComponent = hasGameObjectFlyCameraControllerComponent;
exports.addGameObjectArcballCameraControllerComponent = addGameObjectArcballCameraControllerComponent;
exports.disposeGameObjectArcballCameraControllerComponent = disposeGameObjectArcballCameraControllerComponent;
exports.unsafeGetGameObjectArcballCameraControllerComponent = unsafeGetGameObjectArcballCameraControllerComponent;
exports.hasGameObjectArcballCameraControllerComponent = hasGameObjectArcballCameraControllerComponent;
exports.addGameObjectTransformComponent = addGameObjectTransformComponent;
exports.disposeGameObjectTransformComponent = disposeGameObjectTransformComponent;
exports.unsafeGetGameObjectTransformComponent = unsafeGetGameObjectTransformComponent;
exports.hasGameObjectTransformComponent = hasGameObjectTransformComponent;
exports.addGameObjectGeometryComponent = addGameObjectGeometryComponent;
exports.disposeGameObjectGeometryComponent = disposeGameObjectGeometryComponent;
exports.removeGameObjectGeometryComponent = removeGameObjectGeometryComponent;
exports.removeGameObjectBasicMaterialComponent = removeGameObjectBasicMaterialComponent;
exports.removeGameObjectLightMaterialComponent = removeGameObjectLightMaterialComponent;
exports.unsafeGetGameObjectGeometryComponent = unsafeGetGameObjectGeometryComponent;
exports.hasGameObjectGeometryComponent = hasGameObjectGeometryComponent;
exports.addGameObjectBasicMaterialComponent = addGameObjectBasicMaterialComponent;
exports.disposeGameObjectBasicMaterialComponent = disposeGameObjectBasicMaterialComponent;
exports.unsafeGetGameObjectBasicMaterialComponent = unsafeGetGameObjectBasicMaterialComponent;
exports.hasGameObjectBasicMaterialComponent = hasGameObjectBasicMaterialComponent;
exports.addGameObjectLightMaterialComponent = addGameObjectLightMaterialComponent;
exports.disposeGameObjectLightMaterialComponent = disposeGameObjectLightMaterialComponent;
exports.disposeGameObjectLightMaterialComponentRemoveTexture = disposeGameObjectLightMaterialComponentRemoveTexture;
exports.unsafeGetGameObjectLightMaterialComponent = unsafeGetGameObjectLightMaterialComponent;
exports.hasGameObjectLightMaterialComponent = hasGameObjectLightMaterialComponent;
exports.addGameObjectMeshRendererComponent = addGameObjectMeshRendererComponent;
exports.disposeGameObjectMeshRendererComponent = disposeGameObjectMeshRendererComponent;
exports.unsafeGetGameObjectMeshRendererComponent = unsafeGetGameObjectMeshRendererComponent;
exports.hasGameObjectMeshRendererComponent = hasGameObjectMeshRendererComponent;
exports.addGameObjectDirectionLightComponent = addGameObjectDirectionLightComponent;
exports.disposeGameObjectDirectionLightComponent = disposeGameObjectDirectionLightComponent;
exports.unsafeGetGameObjectDirectionLightComponent = unsafeGetGameObjectDirectionLightComponent;
exports.hasGameObjectDirectionLightComponent = hasGameObjectDirectionLightComponent;
exports.addGameObjectPointLightComponent = addGameObjectPointLightComponent;
exports.disposeGameObjectPointLightComponent = disposeGameObjectPointLightComponent;
exports.unsafeGetGameObjectPointLightComponent = unsafeGetGameObjectPointLightComponent;
exports.hasGameObjectPointLightComponent = hasGameObjectPointLightComponent;
exports.addGameObjectSourceInstanceComponent = addGameObjectSourceInstanceComponent;
exports.unsafeGetGameObjectSourceInstanceComponent = unsafeGetGameObjectSourceInstanceComponent;
exports.hasGameObjectSourceInstanceComponent = hasGameObjectSourceInstanceComponent;
exports.disposeGameObjectSourceInstanceComponent = disposeGameObjectSourceInstanceComponent;
exports.addGameObjectObjectInstanceComponent = addGameObjectObjectInstanceComponent;
exports.unsafeGetGameObjectObjectInstanceComponent = unsafeGetGameObjectObjectInstanceComponent;
exports.disposeGameObjectObjectInstanceComponent = disposeGameObjectObjectInstanceComponent;
exports.isGameObjectAlive = isGameObjectAlive;
exports.disposeGameObject = disposeGameObject;
exports.disposeGameObjectKeepOrder = disposeGameObjectKeepOrder;
exports.disposeGameObjectKeepOrderRemoveGeometry = disposeGameObjectKeepOrderRemoveGeometry;
exports.disposeGameObjectKeepOrderRemoveGeometryRemoveMaterial = disposeGameObjectKeepOrderRemoveGeometryRemoveMaterial;
exports.disposeGameObjectDisposeGeometryRemoveMaterial = disposeGameObjectDisposeGeometryRemoveMaterial;
exports.disposeGameObjectRemoveTexture = disposeGameObjectRemoveTexture;
exports.initGameObject = initGameObject;
exports.batchDisposeGameObject = batchDisposeGameObject;
exports.batchDisposeGameObjectKeepOrder = batchDisposeGameObjectKeepOrder;
exports.cloneGameObject = cloneGameObject;
exports.getGameObjectName = getGameObjectName;
exports.unsafeGetGameObjectName = unsafeGetGameObjectName;
exports.setGameObjectName = setGameObjectName;
exports.unsafeGetGameObjectIsRoot = unsafeGetGameObjectIsRoot;
exports.setGameObjectIsRoot = setGameObjectIsRoot;
exports.getAllChildrenTransform = getAllChildrenTransform;
exports.getAllGameObjects = getAllGameObjects;
exports.getAllDirectionLightComponentsOfGameObject = getAllDirectionLightComponentsOfGameObject;
exports.getAllPointLightComponentsOfGameObject = getAllPointLightComponentsOfGameObject;
exports.getAllGeometryComponents = getAllGeometryComponents;
exports.getAllFlyCameraControllerComponents = getAllFlyCameraControllerComponents;
exports.getAllArcballCameraControllerComponents = getAllArcballCameraControllerComponents;
exports.getAllBasicCameraViewComponents = getAllBasicCameraViewComponents;
exports.getAllPerspectiveCameraProjectionComponents = getAllPerspectiveCameraProjectionComponents;
exports.getAllBasicMaterialComponents = getAllBasicMaterialComponents;
exports.getAllLightMaterialComponents = getAllLightMaterialComponents;
exports.getAllDirectionLightComponents = getAllDirectionLightComponents;
exports.getAllPointLightComponents = getAllPointLightComponents;
exports.unsafeGetGameObjectIsActive = unsafeGetGameObjectIsActive;
exports.setGameObjectIsActive = setGameObjectIsActive;
/* Log-WonderLog Not a pure module */