r3-legacy/bak/r3-d3-api-game.js

/**
 * Raw Game API object - should always correspond with the Game Schema
 * @param id
 * @param name
 * @param gameType
 * @param imageFactory
 * @param width
 * @param height
 * @param baseUrl
 * @param path
 * @param cameras
 * @param renderers
 * @param composers
 * @param renderTargets
 * @param systems
 * @param viewports
 * @param entityManager
 * @param parentEntity
 * @constructor
 */
R3.D3.API.Game = function(
    id,
    name,
    baseUrl,
    path,
    imageFactory,
    gameType,
    cameras,
    composers,
    viewports,
    renderers,
    renderTargets,
    systems,
    entityManager,
    parentEntity
) {
    R3.Component.call(
        this,
        R3.Component.COMPONENT_GAME,
        {
            'imageFactory'  : R3.D3.ImageFactory,
            'cameras'       : [R3.D3.Camera],
            'composers'     : [R3.D3.Composer],
            'viewports'     : [R3.D3.Viewport],
            'renderers'     : [R3.D3.Renderer],
            'renderTargets' : [R3.D3.RenderTarget],
            'systems'       : [R3.System],
            'entityManager' : R3.EntityManager
        },
        null,
        parentEntity
    );

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

    if (R3.Utils.UndefinedOrNull(name)) {
        name = 'Game (' + this.id + ')';
    }
    this.name = name;

    if (R3.Utils.UndefinedOrNull(baseUrl)) {
        baseUrl = '';
        console.warn('The base URL required for downloading images is not set - textured meshes will not render properly');
    }
    this.baseUrl = baseUrl;

    if (R3.Utils.UndefinedOrNull(path)) {
        path = '';
    }
    this.path = path;

    if (R3.Utils.UndefinedOrNull(imageFactory)) {
        imageFactory = null;
    }
    this.imageFactory = imageFactory;

    if (R3.Utils.UndefinedOrNull(gameType)) {
        gameType = R3.D3.Game.GAME_TYPE_VR_PONG;
    }
    this.gameType = gameType;

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

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

    if (R3.Utils.UndefinedOrNull(viewports)) {
        viewports = [];
    }
    this.viewports = viewports;

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

    if (R3.Utils.UndefinedOrNull(renderTargets)) {
        renderTargets = [];
    }
    this.renderTargets = renderTargets;

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

    if (R3.Utils.UndefinedOrNull(entityManager)) {
        entityManager = null;
    }
    this.entityManager = entityManager;

};

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

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

    var apiImageFactory     = null;
    var apiCameras          = [];
    var apiComposers        = [];
    var apiViewports	    = [];
    var apiRenderers        = [];
    var apiRenderTargets    = [];
    var apiSystems          = [];

    var apiEntityManager    = null;

    if (objectGame.imageFactory) {
        apiImageFactory = R3.D3.API.ImageFactory.FromObjectImageFactory(objectGame.imageFactory);
    }

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

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

    if (objectGame.viewports) {
        apiViewports = objectGame.viewports.map(
            function(objectViewport){
                return R3.D3.API.Viewport.FromObjectViewport(objectViewport);
            }
        );
    }

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

    if (objectGame.renderTargets) {
        apiRenderTargets = objectGame.renderTargets.map(
            function(objectRenderTarget){
                return R3.D3.API.RenderTarget.FromObjectComponent(objectRenderTarget);
            }
        );
    }

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

    if (objectGame.entityManager) {
        apiEntityManager = R3.API.EntityManager.FromObjectEntityManager(objectGame.entityManager);
    }

    return new R3.D3.API.Game(
        objectGame.id,
		objectGame.name,
        objectGame.baseUrl,
        objectGame.path,
        apiImageFactory,
		objectGame.gameType,
        apiCameras,
        apiComposers,
        apiViewports,
        apiRenderers,
        apiRenderTargets,
        apiSystems,
        apiEntityManager,
		objectGame.parentEntity
    );

};