Skip to content

Commit

Permalink
v1.9.0
Browse files Browse the repository at this point in the history 
Former-commit-id: 3491ccb
  • Loading branch information
@deltakosh
deltakosh committed Feb 15, 2014
1 parent 7666bb6 commit eaed084
Show file tree
Hide file tree
Showing 8 changed files with 390 additions and 66 deletions.
1 change: 1 addition & 0 deletions Babylon/Materials/textures/babylon.renderTargetTexture.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@ var BABYLON = BABYLON || {};
this._scene.textures.push(this);

this.name = name;
this._size = size;
this._generateMipMaps = generateMipMaps;

this._texture = scene.getEngine().createRenderTargetTexture(size, generateMipMaps);
Expand Down
24 changes: 15 additions & 9 deletions Babylon/Tools/babylon.sceneLoader.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -181,6 +181,7 @@ var BABYLON = BABYLON || {};
var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
if (parsedParticleSystem.textureName) {
particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
particleSystem.particleTexture.name = parsedParticleSystem.textureName;
}
particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
Expand Down Expand Up @@ -487,18 +488,23 @@ var BABYLON = BABYLON || {};
}

if (parsedGeometry.matricesIndices) {
var floatIndices = [];
if (!parsedGeometry.matricesIndices._isExpanded) {
var floatIndices = [];

for (var i = 0; i < parsedGeometry.matricesIndices.length; i++) {
var matricesIndex = parsedGeometry.matricesIndices[i];
for (var i = 0; i < parsedGeometry.matricesIndices.length; i++) {
var matricesIndex = parsedGeometry.matricesIndices[i];

floatIndices.push(matricesIndex & 0x000000FF);
floatIndices.push((matricesIndex & 0x0000FF00) >> 8);
floatIndices.push((matricesIndex & 0x00FF0000) >> 16);
floatIndices.push(matricesIndex >> 24);
}
floatIndices.push(matricesIndex & 0x000000FF);
floatIndices.push((matricesIndex & 0x0000FF00) >> 8);
floatIndices.push((matricesIndex & 0x00FF0000) >> 16);
floatIndices.push(matricesIndex >> 24);
}

mesh.setVerticesData(floatIndices, BABYLON.VertexBuffer.MatricesIndicesKind, false);
mesh.setVerticesData(floatIndices, BABYLON.VertexBuffer.MatricesIndicesKind, false);
} else {
delete parsedGeometry.matricesIndices._isExpanded;
mesh.setVerticesData(parsedGeometry.matricesIndices, BABYLON.VertexBuffer.MatricesIndicesKind, false);
}
}

if (parsedGeometry.matricesWeights) {
Expand Down
286 changes: 280 additions & 6 deletions Babylon/Tools/babylon.sceneSerializer.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -75,7 +75,7 @@ var BABYLON = BABYLON || {};
return serializationObject;
};

var appendAnimations = function(source, destination) {
var appendAnimations = function (source, destination) {
if (source.animations) {
destination.animations = [];
for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
Expand All @@ -97,8 +97,8 @@ var BABYLON = BABYLON || {};

var dataType = animation.dataType;
serializationObject.keys = [];
for (var index = 0; index < animation.keys.length; index++) {
var animationKey = animation.keys[index];
for (var index = 0; index < animation._keys.length; index++) {
var animationKey = animation._keys[index];

var key = {};
key.frame = animationKey.frame;
Expand All @@ -120,6 +120,27 @@ var BABYLON = BABYLON || {};
return serializationObject;
};

var serializeMultiMaterial = function (material) {
var serializationObject = {};

serializationObject.name = material.name;
serializationObject.id = material.id;

serializationObject.materials = [];

for (var matIndex = 0; matIndex < material.subMaterials.length; matIndex++) {
var subMat = material.subMaterials[matIndex];

if (subMat) {
serializationObject.materials.push(subMat.id);
} else {
serializationObject.materials.push(null);
}
}

return serializationObject;
};

var serializeMaterial = function (material) {
var serializationObject = {};

Expand Down Expand Up @@ -224,6 +245,214 @@ var BABYLON = BABYLON || {};
return serializationObject;
};

var serializeSkeleton = function (skeleton) {
var serializationObject = {};

serializationObject.name = skeleton.name;
serializationObject.id = skeleton.id;

serializationObject.bones = [];

for (var index = 0; index < skeleton.bones.length; index++) {
var bone = skeleton.bones[index];

var serializedBone = {
parentBoneIndex: bone._parent ? bone._parent.id : -1,
name: bone.name,
matrix: bone._matrix.toArray()
};

serializationObject.bones.push(serializedBone);

if (bone.animations && bone.animations.length > 0) {
serializedBone.animation = serializeAnimation(bone.animations[0]);
}
}
return serializationObject;
};

var serializeParticleSystem = function (particleSystem) {
var serializationObject = {};

serializationObject.emitterId = particleSystem.emitter.id;
serializationObject.capacity = particleSystem._capacity;

if (particleSystem.particleTexture) {
serializationObject.textureName = particleSystem.particleTexture.name;
}

serializationObject.minAngularSpeed = particleSystem.minAngularSpeed;
serializationObject.maxAngularSpeed = particleSystem.maxAngularSpeed;
serializationObject.minSize = particleSystem.minSize;
serializationObject.maxSize = particleSystem.maxSize;
serializationObject.minLifeTime = particleSystem.minLifeTime;
serializationObject.maxLifeTime = particleSystem.maxLifeTime;
serializationObject.emitRate = particleSystem.emitRate;
serializationObject.minEmitBox = particleSystem.minEmitBox.asArray();
serializationObject.maxEmitBox = particleSystem.maxEmitBox.asArray();
serializationObject.gravity = particleSystem.gravity.asArray();
serializationObject.direction1 = particleSystem.direction1.asArray();
serializationObject.direction2 = particleSystem.direction2.asArray();
serializationObject.color1 = particleSystem.color1.asArray();
serializationObject.color2 = particleSystem.color2.asArray();
serializationObject.colorDead = particleSystem.colorDead.asArray();
serializationObject.updateSpeed = particleSystem.updateSpeed;
serializationObject.targetStopDuration = particleSystem.targetStopFrame;
serializationObject.textureMask = particleSystem.textureMask.asArray();
serializationObject.blendMode = particleSystem.blendMode;

return serializationObject;
};

var serializeLensFlareSystem = function (lensFlareSystem) {
var serializationObject = {};

serializationObject.emitterId = lensFlareSystem._emitter.id;
serializationObject.borderLimit = lensFlareSystem.borderLimit;

serializationObject.flares = [];
for (var index = 0; index < lensFlareSystem.lensFlares.length; index++) {
var flare = lensFlareSystem.lensFlares[index];

serializationObject.flares.push({
size: flare.size,
position: flare.position,
color: flare.color.asArray(),
textureName: BABYLON.Tools.GetFilename(flare.texture.name)
});
}


return serializationObject;
};

var serializeShadowGenerator = function (light) {
var serializationObject = {};
var shadowGenerator = light._shadowGenerator;

serializationObject.lightId = light.id;
serializationObject.mapSize = shadowGenerator.getShadowMap()._size;
serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;

serializationObject.renderList = [];
for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {
var mesh = shadowGenerator.getShadowMap().renderList[meshIndex];

serializationObject.renderList.push(mesh.id);
}

return serializationObject;
};

var serializeMesh = function (mesh) {
var serializationObject = {};

serializationObject.name = mesh.name;
serializationObject.id = mesh.id;

serializationObject.position = mesh.position.asArray();

if (mesh.rotation) {
serializationObject.rotation = mesh.rotation.asArray();
} else if (mesh.rotationQuaternion) {
serializationObject.rotationQuaternion = mesh.rotationQuaternion.asArray();
}

serializationObject.scaling = mesh.scaling.asArray();
serializationObject.localMatrix = mesh.getPivotMatrix().asArray();

serializationObject.isEnabled = mesh.isEnabled();
serializationObject.isVisible = mesh.isVisible;
serializationObject.infiniteDistance = mesh.infiniteDistance;

serializationObject.receiveShadows = mesh.receiveShadows;

serializationObject.billboardMode = mesh.billboardMode;
serializationObject.visibility = mesh.visibility;

serializationObject.checkCollisions = mesh.checkCollisions;

// Parent
if (mesh.parent) {
serializationObject.parentId = mesh.parent.id;
}

// Geometry
if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.PositionKind)) {
serializationObject.positions = mesh.getVerticesData(BABYLON.VertexBuffer.PositionKind);
serializationObject.normals = mesh.getVerticesData(BABYLON.VertexBuffer.NormalKind);

if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
serializationObject.uvs = mesh.getVerticesData(BABYLON.VertexBuffer.UVKind);
}

if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.UV2Kind)) {
serializationObject.uvs2 = mesh.getVerticesData(BABYLON.VertexBuffer.UV2Kind);
}

if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
serializationObject.colors = mesh.getVerticesData(BABYLON.VertexBuffer.ColorKind);
}

if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind)) {
serializationObject.matricesWeights = mesh.getVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind);
}

if (mesh.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind)) {
serializationObject.matricesWeights = mesh.getVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind);
serializationObject.matricesWeights._isExpanded = true;
}

serializationObject.indices = mesh.getIndices();

// SubMeshes
serializationObject.subMeshes = [];
for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
var subMesh = mesh.subMeshes[subIndex];

serializationObject.subMeshes.push({
materialIndex: subMesh.materialIndex,
verticesStart: subMesh.verticesStart,
verticesCount: subMesh.verticesCount,
indexStart: subMesh.indexStart,
indexCount: subMesh.indexCount
});
}
}

// Material
if (mesh.material) {
serializationObject.materialId = mesh.material.id;
} else {
mesh.material = null;
}

// Skeleton
if (mesh.skeleton) {
serializationObject.skeletonId = mesh.skeleton.id;
}

// Physics
if (mesh.getPhysicsImpostor() !== BABYLON.PhysicsEngine.NoImpostor) {
serializationObject.physicsMass = mesh.getPhysicsMass();
serializationObject.physicsFriction = mesh.getPhysicsFriction();
serializationObject.physicsRestitution = mesh.getPhysicsRestitution();

switch (mesh.getPhysicsImpostor()) {
case BABYLON.PhysicsEngine.BoxImpostor:
serializationObject.physicsImpostor = 1;
break;
case BABYLON.PhysicsEngine.SphereImpostor:
serializationObject.physicsImpostor = 2;
break;
}
}

// Animations
appendAnimations(mesh, serializationObject);

return serializationObject;
};

BABYLON.SceneSerializer = {
Serialize: function (scene) {
Expand All @@ -249,7 +478,7 @@ var BABYLON = BABYLON || {};
serializationObject.lights = [];
for (var index = 0; index < scene.lights.length; index++) {
var light = scene.lights[index];

serializationObject.lights.push(serializeLight(light));
}

Expand All @@ -258,18 +487,63 @@ var BABYLON = BABYLON || {};
for (var index = 0; index < scene.cameras.length; index++) {
var camera = scene.cameras[index];

serializationObject.cameras.push(serializeCamera(camera));
if (camera instanceof BABYLON.FreeCamera) {
serializationObject.cameras.push(serializeCamera(camera));
}
}
if (scene.activecamera) {
serializationObject.activeCameraID = scene.activeCamera.id;
}

// Materials
serializationObject.materials = [];
serializationObject.multiMaterials = [];
for (var index = 0; index < scene.materials.length; index++) {
var material = scene.materials[index];

serializationObject.materials.push(serializeMaterial(material));
if (material instanceof BABYLON.StandardMaterial) {
serializationObject.materials.push(serializeMaterial(material));
} else if (material instanceof BABYLON.MultiMaterial) {
serializationObject.multiMaterials.push(serializeMultiMaterial(material));
}
}

// Skeletons
serializationObject.skeletons = [];
for (var index = 0; index < scene.skeletons.length; index++) {
serializationObject.skeletons.push(serializeSkeleton(scene.skeletons[index]));
}

// Meshes
serializationObject.meshes = [];
for (var index = 0; index < scene.meshes.length; index++) {
var mesh = scene.meshes[index];

if (mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADED || mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_NONE) {
serializationObject.meshes.push(serializeMesh(mesh));
}
}

// Particles Systems
serializationObject.particleSystems = [];
for (var index = 0; index < scene.particleSystems.length; index++) {
serializationObject.particleSystems.push(serializeParticleSystem(scene.particleSystems[index]));
}

// Lens flares
serializationObject.lensFlareSystems = [];
for (var index = 0; index < scene.lensFlareSystems.length; index++) {
serializationObject.lensFlareSystems.push(serializeLensFlareSystem(scene.lensFlareSystems[index]));
}

// Shadows
serializationObject.shadowGenerators = [];
for (var index = 0; index < scene.lights.length; index++) {
var light = scene.lights[index];

if (light._shadowGenerator) {
serializationObject.shadowGenerators.push(serializeShadowGenerator(light));
}
}

return serializationObject;
Expand Down

0 comments on commit eaed084

Please sign in to comment.