r3-legacy/src/game-lib-d3-api-game.js

/**
 * Raw Game API object - should always correspond with the Game Schema
 * @param id
 * @param name
 * @param gameType
 * @param width
 * @param height
 * @param scenes
 * @param cameras
 * @param renderers
 * @param composers
 * @param systems
 * @param entityManager
 * @param mouse
 * @param raycaster
 * @param activeCameraIndex
 * @param activeRendererIndex
 * @param parentEntity
 * @constructor
 */
GameLib.D3.API.Game = function(
    id,
    name,
    gameType,
    width,
    height,
    scenes,
    cameras,
    renderers,
    composers,
    systems,
    entityManager,
    mouse,
    raycaster,
    activeCameraIndex,
    activeRendererIndex,
    parentEntity
) {
    GameLib.Component.call(
        this,
        GameLib.Component.COMPONENT_GAME,
        {
            'scenes'        : [GameLib.D3.Scene],
            'cameras'       : [GameLib.D3.Camera],
            'renderers'     : [GameLib.D3.Renderer],
            'composers'     : [GameLib.D3.Composer],
            'systems'       : [GameLib.D3.System],
            'entityManager' : GameLib.EntityManager,
            'mouse'         : GameLib.D3.Mouse,
            'raycaster'     : GameLib.D3.Raycaster
        },
        null,
        parentEntity
    );

    if (GameLib.Utils.UndefinedOrNull(id)) {
        id = GameLib.Utils.RandomId();
    }
    this.id = id;

    if (GameLib.Utils.UndefinedOrNull(name)) {
        name = 'Game (' + this.id + ')';
    }
    this.name = name;
    
    if (GameLib.Utils.UndefinedOrNull(gameType)) {
        gameType = GameLib.D3.Game.GAME_TYPE_VR_PONG;
    }
    this.gameType = gameType;

    if (GameLib.Utils.UndefinedOrNull(width)) {
        width = 800;
    }
    this.width = width;

    if (GameLib.Utils.UndefinedOrNull(height)) {
        height = 600;
    }
    this.height = height;

    if (GameLib.Utils.UndefinedOrNull(scenes)) {
        scenes = [];
    }
    this.scenes = scenes;

    if (GameLib.Utils.UndefinedOrNull(cameras)) {
        cameras = [];
    }
    this.cameras = cameras;

    if (GameLib.Utils.UndefinedOrNull(renderers)) {
        renderers = [];
    }
    this.renderers = renderers;

    if (GameLib.Utils.UndefinedOrNull(composers)) {
        composers = [];
    }
    this.composers = composers;

    if (GameLib.Utils.UndefinedOrNull(systems)) {
        systems = [];
    }
    this.systems = systems;

    if (GameLib.Utils.UndefinedOrNull(entityManager)) {
        entityManager = new GameLib.API.EntityManager();
    }
    this.entityManager = entityManager;
    
    if (GameLib.Utils.UndefinedOrNull(mouse)) {
        mouse = null;
    }
    this.mouse = mouse;

    if (GameLib.Utils.UndefinedOrNull(raycaster)) {
        raycaster = null;
    }
    this.raycaster = raycaster;

    if (GameLib.Utils.UndefinedOrNull(activeCameraIndex)) {
        activeCameraIndex = 0;
    }
    this.activeCameraIndex = activeCameraIndex;

    if (GameLib.Utils.UndefinedOrNull(activeRendererIndex)) {
        activeRendererIndex = 0;
    }
    this.activeRendererIndex = activeRendererIndex;
};

GameLib.D3.API.Game.prototype = Object.create(GameLib.Component.prototype);
GameLib.D3.API.Game.prototype.constructor = GameLib.D3.API.Game;

/**
 * Creates an API camera from an Object camera
 * @param objectGame
 * @constructor
 */
GameLib.D3.API.Game.FromObjectGame = function(objectGame) {

    var apiScenes       = [];
    var apiCameras      = [];
    var apiRenderers    = [];
    var apiComposers    = [];
    var apiSystems      = [];

    var apiEntityManager    = null;
    var apiMouse            = null;
    var apiRaycaster        = null;

    if (objectGame.scenes) {
        apiScenes = objectGame.scenes.map(
            function(objectScene){
                return GameLib.API.Scene.FromObjectScene(objectScene);
            }
        );
    }

    if (objectGame.cameras) {
        apiCameras = objectGame.cameras.map(
            function(objectCamera){
                return GameLib.API.Camera.FromObjectCamera(objectCamera);
            }
        );
    }

    if (objectGame.renderers) {
        apiRenderers = objectGame.renderers.map(
            function(objectRenderer){
                return GameLib.API.Renderer.FromObjectComponent(objectRenderer);
            }
        );
    }

    if (objectGame.composers) {
        apiComposers = objectGame.composers.map(
            function(objectComposer){
                return GameLib.API.Composer.FromObjectComponent(objectComposer);
            }
        );
    }

    if (objectGame.systems) {
        apiSystems = objectGame.systems.map(
            function(objectSystem){
                return GameLib.API.System.FromObjectComponent(objectSystem);
            }
        );
    }

    if (objectGame.entityManager) {
        apiEntityManager = GameLib.API.Entity.FromObjectEntity(objectGame.entityManager);
    }

    if (objectGame.mouse) {
        apiMouse = GameLib.API.Mouse.FromObjectMouse(objectGame.mouse);
    }

    if (objectGame.raycaster) {
        apiRaycaster = GameLib.API.Raycaster.FromObjectRaycaster(objectGame.raycaster);
    }

    return new GameLib.D3.API.Game(
        objectGame.id,
		objectGame.name,
		objectGame.gameType,
		objectGame.width,
		objectGame.height,
        apiScenes,
        apiCameras,
        apiRenderers,
        apiComposers,
        apiSystems,
        apiEntityManager,
        apiMouse,
        apiRaycaster,
		objectGame.activeCameraIndex,
		objectGame.activeRendererIndex,
		objectGame.parentEntity
    );

};