void SceneParticleEmitter::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const {
SceneMesh::applyClone(clone, deepClone, ignoreEditorOnly);
SceneParticleEmitter *cloneEmitter = (SceneParticleEmitter*) clone;
cloneEmitter->setParticleCount(particleCount);
cloneEmitter->setParticleSpeed(particleSpeed);
cloneEmitter->setParticleLifetime(lifetime);
cloneEmitter->setParticleDirection(directionVector);
cloneEmitter->setDirectionDeviation(directionDeviation);
cloneEmitter->setEmitterSize(emitterSize);
cloneEmitter->setGravity(gravity);
cloneEmitter->setUseFloorPlane(useFloorPlane);
cloneEmitter->setParticlesInWorldSpace(particlesInWorldSpace);
cloneEmitter->setPerlinEnabled(perlinEnabled);
cloneEmitter->setPerlinValue(perlinValue);
cloneEmitter->setParticleSize(particleSize);
cloneEmitter->setFloorPlaneOffset(floorPlaneOffset);
cloneEmitter->setFloorDamping(floorDamping);
cloneEmitter->setLoopParticles(loopParticles);
cloneEmitter->setParticleType(particleType);
cloneEmitter->scaleCurve = scaleCurve;
cloneEmitter->useScaleCurve = useScaleCurve;
cloneEmitter->colorCurveR = colorCurveR;
cloneEmitter->colorCurveG = colorCurveG;
cloneEmitter->colorCurveB = colorCurveB;
cloneEmitter->colorCurveA = colorCurveA;
cloneEmitter->useColorCurves = useColorCurves;
cloneEmitter->getMesh()->useVertexColors = true;
}
Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entity *targetEntity, int entityFileVersion) {
Entity *entity = NULL;
ObjectEntry *entityType = (*entry)["type"];
if(entityType) {
if(entityType->stringVal == "SceneEntityInstance") {
ObjectEntry *instanceEntry = (*entry)["SceneEntityInstance"];
String filePath = (*instanceEntry)["filePath"]->stringVal;
SceneEntityInstance *instance = new SceneEntityInstance(parentScene, filePath);
entity = instance;
} else if(entityType->stringVal == "SceneCurve") {
ObjectEntry *curveEntry = (*entry)["SceneCurve"];
SceneCurve *curve = new SceneCurve();
if(curveEntry) {
curve->renderCurve = (*curveEntry)["render"]->boolVal;
curve->curveResolution = (*curveEntry)["resolution"]->intVal;
parseObjectIntoCurve((*curveEntry)["curve"], curve->getCurve());
}
entity = curve;
} else if(entityType->stringVal == "SceneSprite") {
ObjectEntry *spriteEntry = (*entry)["SceneSprite"];
String spriteSetName = (*spriteEntry)["sprite_set"]->stringVal;
SpriteSet *spriteSet = (SpriteSet*)CoreServices::getInstance()->getResourceManager()->getResourcePoolByName(spriteSetName);
if(spriteSet) {
SceneSprite *sprite = new SceneSprite(spriteSet);
String spriteName = (*spriteEntry)["sprite"]->stringVal;
sprite->setSpriteByName(spriteName);
String stateName = (*spriteEntry)["state"]->stringVal;
if(sprite->getCurrentSprite()) {
SpriteState *state = sprite->getCurrentSprite()->getStateByName(stateName);
if(state) {
sprite->setSpriteState(state, 0, false);
}
ObjectEntry *randomFrameEntry = (*spriteEntry)["random_frame"];
if(randomFrameEntry) {
sprite->setStartOnRandomFrame(randomFrameEntry->boolVal);
}
}
entity = sprite;
applySceneMesh((*entry)["SceneMesh"], sprite);
}
} else if(entityType->stringVal == "SceneLabel") {
ObjectEntry *labelEntry = (*entry)["SceneLabel"];
String text = (*labelEntry)["text"]->stringVal;
String font = (*labelEntry)["font"]->stringVal;
int size = (*labelEntry)["size"]->intVal;
Number actualHeight = (*labelEntry)["actualHeight"]->intVal;
int aaMode = (*labelEntry)["aaMode"]->intVal;
SceneLabel *label = new SceneLabel(text, size, font, aaMode, actualHeight);
label->setAnchorPoint(0.0, 0.0, 0.0);
label->snapToPixels = false;
label->positionAtBaseline = false;
applySceneMesh((*entry)["SceneMesh"], label);
// RENDERER_TODO
/*
if(label->getLocalShaderOptions()) {
label->getLocalShaderOptions()->clearTexture("diffuse");
label->getLocalShaderOptions()->addTexture("diffuse", label->getTexture());
}
*/
entity = label;
} else if(entityType->stringVal == "SceneParticleEmitter") {
ObjectEntry *emitterEntry = (*entry)["SceneParticleEmitter"];
SceneParticleEmitter *emitter = new SceneParticleEmitter(1, 1, 1);
emitter->setParticleType((*emitterEntry)["type"]->intVal);
emitter->setParticleSpeed((*emitterEntry)["speed"]->NumberVal);
emitter->setParticleCount((*emitterEntry)["count"]->intVal);
emitter->setParticleLifetime((*emitterEntry)["lifetime"]->NumberVal);
emitter->setParticleSize((*emitterEntry)["size"]->NumberVal);
emitter->setParticlesInWorldSpace((*emitterEntry)["world"]->boolVal);
emitter->setLoopParticles((*emitterEntry)["loop"]->boolVal);
emitter->setParticleRotationSpeed(Vector3((*emitterEntry)["rX"]->NumberVal, (*emitterEntry)["rY"]->NumberVal, (*emitterEntry)["rZ"]->NumberVal));
emitter->setGravity(Vector3((*emitterEntry)["gX"]->NumberVal, (*emitterEntry)["gY"]->NumberVal, (*emitterEntry)["gZ"]->NumberVal));
emitter->setParticleDirection(Vector3((*emitterEntry)["dirX"]->NumberVal, (*emitterEntry)["dirY"]->NumberVal, (*emitterEntry)["dirZ"]->NumberVal));
emitter->setEmitterSize(Vector3((*emitterEntry)["eX"]->NumberVal, (*emitterEntry)["eY"]->NumberVal, (*emitterEntry)["eZ"]->NumberVal));
emitter->setDirectionDeviation(Vector3((*emitterEntry)["devX"]->NumberVal, (*emitterEntry)["devY"]->NumberVal, (*emitterEntry)["devZ"]->NumberVal));
emitter->setPerlinEnabled((*emitterEntry)["perlin"]->boolVal);
if(emitter->getPerlinEnabled()) {
emitter->setPerlinValue(Vector3((*emitterEntry)["pX"]->NumberVal, (*emitterEntry)["pY"]->NumberVal, (*emitterEntry)["pZ"]->NumberVal));
}
emitter->useColorCurves = (*emitterEntry)["useColorCurves"]->boolVal;
emitter->useScaleCurve = (*emitterEntry)["useScaleCurve"]->boolVal;
parseObjectIntoCurve((*emitterEntry)["colorCurveR"], &emitter->colorCurveR);
parseObjectIntoCurve((*emitterEntry)["colorCurveG"], &emitter->colorCurveG);
parseObjectIntoCurve((*emitterEntry)["colorCurveB"], &emitter->colorCurveB);
parseObjectIntoCurve((*emitterEntry)["colorCurveA"], &emitter->colorCurveA);
parseObjectIntoCurve((*emitterEntry)["scaleCurve"], &emitter->scaleCurve);
applySceneMesh((*entry)["SceneMesh"], emitter);
entity = emitter;
} else if(entityType->stringVal == "SceneLight") {
ObjectEntry *lightEntry = (*entry)["SceneLight"];
if(lightEntry) {
int lightType = (*lightEntry)["type"]->intVal;
SceneLight *newLight = new SceneLight(lightType, parentScene, 0);
newLight->setIntensity((*lightEntry)["intensity"]->NumberVal);
ObjectEntry *importanceEntry = (*lightEntry)["importance"];
if(importanceEntry) {
newLight->setLightImportance(importanceEntry->intVal);
}
newLight->setDiffuseLightColor((*lightEntry)["cR"]->NumberVal, (*lightEntry)["cG"]->NumberVal, (*lightEntry)["cB"]->NumberVal, (*lightEntry)["cA"]->NumberVal);
newLight->setSpecularLightColor((*lightEntry)["scR"]->NumberVal, (*lightEntry)["scG"]->NumberVal, (*lightEntry)["scB"]->NumberVal, (*lightEntry)["scA"]->NumberVal);
newLight->setAttenuation((*lightEntry)["cAtt"]->NumberVal, (*lightEntry)["lAtt"]->NumberVal, (*lightEntry)["qAtt"]->NumberVal);
if(newLight->getType() == SceneLight::SPOT_LIGHT) {
newLight->setSpotlightProperties((*lightEntry)["spotCutoff"]->NumberVal, (*lightEntry)["spotExponent"]->NumberVal);
if((*lightEntry)["shadows"]->boolVal) {
newLight->enableShadows(true, (*lightEntry)["shadowmapRes"]->intVal);
newLight->setShadowMapFOV((*lightEntry)["shadowmapFOV"]->NumberVal);
}
}
parentScene->addLight(newLight);
entity = newLight;
}
} else if(entityType->stringVal == "ScenePrimitive") {
ObjectEntry *scenePrimitiveEntry = (*entry)["ScenePrimitive"];
int pType = (*scenePrimitiveEntry)["type"]->intVal;
Number p1 = (*scenePrimitiveEntry)["p1"]->NumberVal;
Number p2 = (*scenePrimitiveEntry)["p2"]->NumberVal;
Number p3 = (*scenePrimitiveEntry)["p3"]->NumberVal;
Number p4 = (*scenePrimitiveEntry)["p4"]->NumberVal;
Number p5 = (*scenePrimitiveEntry)["p5"]->NumberVal;
ScenePrimitive *primitive = new ScenePrimitive(pType, p1, p2, p3, p4, p5);
entity = primitive;
applySceneMesh((*entry)["SceneMesh"], primitive);
} else if(entityType->stringVal == "SceneMesh") {
ObjectEntry *meshEntry = (*entry)["SceneMesh"];
if(meshEntry) {
ObjectEntry *fileName = (*meshEntry)["file"];
if(fileName) {
SceneMesh *newMesh = new SceneMesh(fileName->stringVal);
applySceneMesh(meshEntry, newMesh);
// RENDERER_TODO
//newMesh->cacheToVertexBuffer(true);
entity = newMesh;
}
}
} else if(entityType->stringVal == "SceneSound") {
ObjectEntry *soundEntry = (*entry)["SceneSound"];
String filePath = (*soundEntry)["filePath"]->stringVal;
Number refDistance = (*soundEntry)["refDistance"]->NumberVal;
Number maxDistance = (*soundEntry)["maxDistance"]->NumberVal;
Number volume = (*soundEntry)["volume"]->NumberVal;
Number pitch = (*soundEntry)["pitch"]->NumberVal;
SceneSound *sound = new SceneSound(filePath, refDistance, maxDistance);
sound->getSound()->setVolume(volume);
sound->getSound()->setPitch(pitch);
if((*soundEntry)["loopOnLoad"]) {
bool loopOnLoad = (*soundEntry)["loopOnLoad"]->boolVal;
sound->setLoopOnLoad(loopOnLoad);
if(loopOnLoad) {
sound->getSound()->Play(true);
}
}
entity = sound;
} else if(entityType->stringVal == "Camera") {
ObjectEntry *cameraEntry = (*entry)["Camera"];
Camera *camera = new Camera(parentScene);
camera->setExposureLevel((*cameraEntry)["exposure"]->NumberVal);
camera->setClippingPlanes((*cameraEntry)["nearClip"]->NumberVal, (*cameraEntry)["farClip"]->NumberVal);
camera->setOrthoMode((*cameraEntry)["ortho"]->boolVal);
if(camera->getOrthoMode()) {
camera->setOrthoSizeMode((*cameraEntry)["sizeMode"]->intVal);
camera->setOrthoSize((*cameraEntry)["orthoWidth"]->NumberVal, (*cameraEntry)["orthoHeight"]->NumberVal);
} else {
camera->setFOV((*cameraEntry)["fov"]->NumberVal);
}
entity = camera;
}
}
if(!entity) {
if(targetEntity) {
entity = targetEntity;
} else {
entity = new Entity();
}
}
entity->ownsChildren = true;
Vector3 bBox;
entry->readNumber("bbX", &bBox.x);
entry->readNumber("bbY", &bBox.y);
entry->readNumber("bbZ", &bBox.z);
entity->setLocalBoundingBox(bBox);
entity->color.r = (*entry)["cR"]->NumberVal;
entity->color.g = (*entry)["cG"]->NumberVal;
entity->color.b = (*entry)["cB"]->NumberVal;
entity->color.a = (*entry)["cA"]->NumberVal;
if(!targetEntity) {
entity->setBlendingMode((*entry)["blendMode"]->intVal);
entity->setScale((*entry)["sX"]->NumberVal, (*entry)["sY"]->NumberVal, (*entry)["sZ"]->NumberVal);
entity->setPosition((*entry)["pX"]->NumberVal, (*entry)["pY"]->NumberVal, (*entry)["pZ"]->NumberVal);
if(entityFileVersion > 1) {
entity->setRotationQuat((*entry)["rW"]->NumberVal, (*entry)["rX"]->NumberVal, (*entry)["rY"]->NumberVal, (*entry)["rZ"]->NumberVal);
} else {
entity->setRotationEuler(Vector3((*entry)["rX"]->NumberVal, (*entry)["rY"]->NumberVal, (*entry)["rZ"]->NumberVal));
}
}
if((*entry)["id"]->stringVal != "") {
entity->id = (*entry)["id"]->stringVal;
}
if((*entry)["layerID"]) {
entity->layerID = (unsigned int)((*entry)["layerID"]->intVal);
}
String tagString = (*entry)["tags"]->stringVal;
if(tagString != "") {
std::vector<String> tags = tagString.split(",");
for(int i=0; i < tags.size(); i++) {
entity->addTag(tags[i]);
}
}
ObjectEntry *props = (*entry)["props"];
if(props) {
for(int i=0; i < props->length; i++) {
ObjectEntry *prop = ((*props))[i];
if(prop) {
entity->setEntityProp((*prop)["name"]->stringVal, (*prop)["value"]->stringVal);
}
}
}
ObjectEntry *children = (*entry)["children"];
if(children) {
for(int i=0; i < children->length; i++) {
ObjectEntry *childEntry = ((*children))[i];
ScreenEntity *childEntity = loadObjectEntryIntoEntity(childEntry, NULL, entityFileVersion);
entity->addChild(childEntity);
}
}
return entity;
}