397 lines
9.5 KiB
JavaScript
397 lines
9.5 KiB
JavaScript
/**
|
|
* Scene Superset - The apiScene properties get moved into the Scene object itself, and then the instance is
|
|
* created
|
|
* @param graphics
|
|
* @param progressCallback
|
|
* @param apiScene GameLib.D3.API.Scene
|
|
* @param imageFactory
|
|
* @constructor
|
|
*/
|
|
GameLib.D3.Scene = function Scene(
|
|
graphics,
|
|
progressCallback,
|
|
apiScene,
|
|
imageFactory
|
|
) {
|
|
this.graphics = graphics;
|
|
this.graphics.isNotThreeThrow();
|
|
|
|
GameLib.D3.API.Scene.call(
|
|
this,
|
|
apiScene.id,
|
|
apiScene.path,
|
|
apiScene.name,
|
|
apiScene.meshes,
|
|
apiScene.position,
|
|
apiScene.quaternion,
|
|
apiScene.scale,
|
|
apiScene.parentSceneId,
|
|
apiScene.lights,
|
|
apiScene.worlds,
|
|
apiScene.entityManager,
|
|
apiScene.shapes,
|
|
apiScene.cameras,
|
|
apiScene.activeCameraIndex,
|
|
apiScene.splines
|
|
);
|
|
|
|
this.position = new GameLib.Vector3(
|
|
graphics,
|
|
this,
|
|
this.position
|
|
);
|
|
|
|
this.quaternion = new GameLib.Quaternion(
|
|
graphics,
|
|
this,
|
|
this.quaternion
|
|
);
|
|
|
|
this.scale = new GameLib.Vector3(
|
|
graphics,
|
|
this,
|
|
this.scale
|
|
);
|
|
|
|
this.entityManager = new GameLib.EntityManager(
|
|
this,
|
|
this.entityManager
|
|
);
|
|
|
|
this.progressCallback = progressCallback;
|
|
|
|
this.instance = this.createInstance();
|
|
|
|
this.imageFactory = imageFactory;
|
|
|
|
this.interestingProperties = [
|
|
"cameras",
|
|
"meshes",
|
|
"lights",
|
|
"splines"
|
|
];
|
|
|
|
this.idToObject = {};
|
|
|
|
this.idToObject[this.id] = this;
|
|
|
|
for (var p = 0; p < this.interestingProperties.length; p++) {
|
|
property = this.interestingProperties[p];
|
|
if (this.hasOwnProperty(property)) {
|
|
for (var i = 0; i < this[property].length; i++) {
|
|
var object = this[property][i];
|
|
this.idToObject[object.id] = object;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.entityManager.entities.map(
|
|
function (entity) {
|
|
this.idToObject[entity.id] = entity;
|
|
entity.components.map(
|
|
function(component) {
|
|
if (component instanceof GameLib.Component) {
|
|
this.idToObject[component.id] = component;
|
|
}
|
|
}.bind(this)
|
|
)
|
|
}.bind(this)
|
|
);
|
|
|
|
this.entityManager.linkObjects(this.idToObject);
|
|
};
|
|
|
|
GameLib.D3.Scene.prototype = Object.create(GameLib.D3.API.Scene.prototype);
|
|
GameLib.D3.Scene.prototype.constructor = GameLib.D3.Scene;
|
|
|
|
/**
|
|
* Creates an instance scene
|
|
* @returns {GameLib.D3.Scene|THREE.Scene|ApiLib.Scene|*|Scene}
|
|
*/
|
|
GameLib.D3.Scene.prototype.createInstance = function() {
|
|
|
|
var instance = new THREE.Scene();
|
|
|
|
instance.name = this.name;
|
|
|
|
instance.position = this.position.instance;
|
|
|
|
instance.scale = this.scale.instance;
|
|
|
|
instance.quaternion = this.quaternion.instance;
|
|
|
|
for (var im = 0; im < this.meshes.length; im++) {
|
|
instance.add(this.meshes[im].instance);
|
|
}
|
|
|
|
for (var l = 0; l < this.lights.length; l++) {
|
|
instance.add(this.lights[l].instance);
|
|
}
|
|
|
|
instance.render = true;
|
|
|
|
return instance;
|
|
};
|
|
|
|
/**
|
|
* Converts a GameLib.D3.Scene to a GameLib.D3.API.Scene
|
|
* @returns {GameLib.D3.API.Scene}
|
|
*/
|
|
GameLib.D3.Scene.prototype.toApiScene = function() {
|
|
|
|
var apiMeshes = this.meshes.map(
|
|
function(mesh) {
|
|
return mesh.toApiMesh();
|
|
}
|
|
);
|
|
|
|
var apiLights = this.lights.map(
|
|
function(light) {
|
|
return light.toApiLight();
|
|
}
|
|
);
|
|
|
|
var apiEntityManager = null;
|
|
if (this.entityManager) {
|
|
apiEntityManager = this.entityManager.toApiEntityManager();
|
|
}
|
|
|
|
var apiCameras = this.cameras.map(
|
|
function(camera) {
|
|
return camera.toApiCamera();
|
|
}
|
|
);
|
|
|
|
var apiSplines = this.splines.map(
|
|
function(spline) {
|
|
return spline.toApiSpline();
|
|
}
|
|
);
|
|
|
|
var apiWorlds = this.worlds.map(
|
|
function(world) {
|
|
return world.toApiWorld();
|
|
}
|
|
);
|
|
|
|
var apiShapes = this.shapes.map(
|
|
function(shape) {
|
|
return shape.toApiShape();
|
|
}
|
|
);
|
|
|
|
return new GameLib.D3.API.Scene(
|
|
this.id,
|
|
this.path,
|
|
this.name,
|
|
apiMeshes,
|
|
this.position.toApiVector(),
|
|
this.quaternion.toApiQuaternion(),
|
|
this.scale.toApiVector(),
|
|
this.parentSceneId,
|
|
apiLights,
|
|
apiWorlds,
|
|
apiEntityManager,
|
|
apiShapes,
|
|
apiCameras,
|
|
this.activeCameraIndex,
|
|
apiSplines
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Converts a scene Object to a GameLib.D3.Scene object
|
|
* @param graphics GameLib.D3.Graphics
|
|
* @param objectScene Object
|
|
* @param computeNormals boolean to indicate whether or not to recalculate normals
|
|
* @param imageFactory GameLib.D3.ImageFactory
|
|
* @param progressCallback callback
|
|
* @returns {GameLib.D3.Scene}
|
|
* @constructor
|
|
*/
|
|
GameLib.D3.Scene.FromObjectScene = function(
|
|
graphics,
|
|
objectScene,
|
|
computeNormals,
|
|
imageFactory,
|
|
progressCallback
|
|
) {
|
|
var apiScene = new GameLib.D3.API.Scene(
|
|
objectScene.id,
|
|
objectScene.path,
|
|
objectScene.name,
|
|
objectScene.meshes.map(
|
|
function (objectMesh) {
|
|
return GameLib.D3.Mesh.FromObjectMesh(
|
|
graphics,
|
|
objectMesh,
|
|
computeNormals,
|
|
imageFactory
|
|
)
|
|
}
|
|
),
|
|
new GameLib.API.Vector3(
|
|
objectScene.position.x,
|
|
objectScene.position.y,
|
|
objectScene.position.z
|
|
),
|
|
new GameLib.API.Quaternion(
|
|
objectScene.quaternion.x,
|
|
objectScene.quaternion.y,
|
|
objectScene.quaternion.z,
|
|
objectScene.quaternion.w,
|
|
new GameLib.API.Vector3(
|
|
objectScene.quaternion.axis.x,
|
|
objectScene.quaternion.axis.y,
|
|
objectScene.quaternion.axis.z
|
|
),
|
|
objectScene.quaternion.angle
|
|
),
|
|
new GameLib.API.Vector3(
|
|
objectScene.scale.x,
|
|
objectScene.scale.y,
|
|
objectScene.scale.z
|
|
),
|
|
objectScene.parentSceneId,
|
|
objectScene.lights.map(
|
|
function (objectLight) {
|
|
return GameLib.D3.Light.FromObjectLight(
|
|
graphics,
|
|
objectLight
|
|
)
|
|
}
|
|
),
|
|
objectScene.worlds.map(
|
|
function (objectWorld) {
|
|
return GameLib.D3.World.FromObjectWorld(
|
|
graphics,
|
|
objectWorld
|
|
);
|
|
}
|
|
),
|
|
GameLib.EntityManager.FromObjectEntityManager(
|
|
graphics,
|
|
objectScene.entityManager
|
|
),
|
|
objectScene.shapes.map(
|
|
function (objectShape) {
|
|
return GameLib.D3.Shape.FromObjectShape(
|
|
graphics,
|
|
objectShape
|
|
);
|
|
}
|
|
),
|
|
objectScene.cameras.map(
|
|
function (objectCamera) {
|
|
return GameLib.D3.Camera.FromObjectCamera(
|
|
graphics,
|
|
objectCamera
|
|
);
|
|
}
|
|
),
|
|
objectScene.activeCameraIndex,
|
|
objectScene.splines.map(
|
|
function (objectSpline) {
|
|
return GameLib.D3.Spline.FromObjectSpline(
|
|
graphics,
|
|
objectSpline
|
|
)
|
|
}
|
|
)
|
|
);
|
|
|
|
return new GameLib.D3.Scene(
|
|
graphics,
|
|
progressCallback,
|
|
apiScene,
|
|
imageFactory
|
|
);
|
|
|
|
};
|
|
|
|
/**
|
|
* Transforms raw scene data into a GameLib.D3.Scene
|
|
* @param objectScene Object (as it comes from the API)
|
|
* @param onLoaded
|
|
* @param graphics
|
|
* @param uploadUrl
|
|
* @param progressCallback
|
|
* @param computeNormals
|
|
* @constructor
|
|
*/
|
|
GameLib.D3.Scene.LoadScene = function(
|
|
objectScene,
|
|
onLoaded,
|
|
graphics,
|
|
uploadUrl,
|
|
progressCallback,
|
|
computeNormals
|
|
) {
|
|
onLoaded(
|
|
GameLib.D3.Scene.FromObjectScene(
|
|
graphics,
|
|
objectScene,
|
|
computeNormals,
|
|
GameLib.D3.ImageFactory(
|
|
graphics,
|
|
uploadUrl
|
|
),
|
|
progressCallback
|
|
)
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Loads a scene directly from the API
|
|
* @param partialSceneObject Object {path: '', name: ''}
|
|
* @param onLoaded callback
|
|
* @param graphics GameLib.D3.Graphics
|
|
* @param uploadUrl String
|
|
* @param progressCallback callback
|
|
* @param apiUrl
|
|
*/
|
|
GameLib.D3.Scene.LoadSceneFromApi = function(
|
|
partialSceneObject,
|
|
onLoaded,
|
|
graphics,
|
|
uploadUrl,
|
|
progressCallback,
|
|
apiUrl
|
|
) {
|
|
|
|
/**
|
|
* First check if this is a client or server side request
|
|
*/
|
|
if (typeof XMLHttpRequest == 'undefined') {
|
|
console.warn('implement server side loading from API here');
|
|
return onLoaded(null, new Error('not implemented'));
|
|
}
|
|
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open(
|
|
'GET',
|
|
apiUrl + '/scene/load' + partialSceneObject.path + '/' + partialSceneObject.name
|
|
);
|
|
|
|
xhr.onreadystatechange = function(xhr) {
|
|
|
|
return function() {
|
|
|
|
if (xhr.readyState == 4) {
|
|
|
|
var response = JSON.parse(xhr.responseText);
|
|
|
|
if (!response.scene || response.scene.length == 0) {
|
|
return onLoaded(null, null, new Error('Could not load scene'));
|
|
}
|
|
|
|
var scene = response.scene[0];
|
|
|
|
GameLib.D3.Scene.LoadScene(scene, onLoaded, graphics, uploadUrl, progressCallback, true);
|
|
}
|
|
}
|
|
}(xhr);
|
|
|
|
xhr.send();
|
|
};
|