Implemented saving and loading of most of the entity editor entity types, cleaned up some old shader code

Core/Contents/Include/PolyMaterialManager.h

@@ -24,6 +24,7 @@ THE SOFTWARE.
 #include "PolyGlobals.h"
 #include "PolyImage.h"
 #include "PolyObject.h"
+#include "PolyShader.h"
 #include <vector>
 
 class TiXmlNode;

Core/Contents/Include/PolySceneEntityInstance.h

@@ -28,7 +28,9 @@ THE SOFTWARE.
 #include "PolyParticleEmitter.h"
 #include "PolyScenePrimitive.h"
 #include "PolyResource.h"
+#include "PolySceneSprite.h"
 #include "PolyBezierCurve.h"
+#include "PolyScene.h"
 #include "PolySound.h"
 
 namespace Polycode {
@@ -37,7 +39,7 @@ class SceneEntityInstanceResourceEntry;
 
 class SceneEntityInstance : public Entity {
 	public:
-		SceneEntityInstance(const String& fileName);
+		SceneEntityInstance(Scene *parentScene, const String& fileName);
 		SceneEntityInstance();
 		
 		static SceneEntityInstance *BlankSceneEntityInstance();
@@ -52,10 +54,9 @@ class SceneEntityInstance : public Entity {
 		void clearInstance();
 
 		void parseObjectIntoCurve(ObjectEntry *entry, BezierCurve *curve);
-		void applyScenePrimitive(ObjectEntry *entry, ScenePrimitive *primitive);
 		Entity *loadObjectEntryIntoEntity(ObjectEntry *entry, Entity *targetEntity = NULL);
 		bool loadFromFile(const String& fileName);
-		
+        void applySceneMesh(ObjectEntry *entry, SceneMesh *sceneMesh);
 		
 		SceneEntityInstanceResourceEntry *getResourceEntry();
 		
@@ -67,6 +68,7 @@ class SceneEntityInstance : public Entity {
 		
 	protected:
 		
+        Scene *parentScene;
 		SceneEntityInstanceResourceEntry *resourceEntry;
 		
 };

Core/Contents/Include/PolySceneMesh.h

@@ -155,7 +155,11 @@ namespace Polycode {
 			bool showVertexNormals;
 	
 			void setLineWidth(Number newWidth);
-					
+
+            String getFilename();
+        
+            void loadFromFile(String fileName);
+        
 			Number lineWidth;
 			bool lineSmooth;
 			
@@ -188,5 +192,6 @@ namespace Polycode {
 			Material *material;
 			Skeleton *skeleton;
 			ShaderBinding *localShaderOptions;
+            String fileName;
 	};
 }

Core/Contents/Include/PolyShader.h

@@ -124,7 +124,10 @@ namespace Polycode {
 	};
 	
 	class LocalShaderParam : public PolyBase {
-		public:	
+		public:
+        
+            LocalShaderParam();
+        
 			String name;
 			void *data;
 		
@@ -137,6 +140,8 @@ namespace Polycode {
 		void setVector2(Vector2 x) { memcpy(data, &x, sizeof(x)); }
 		void setVector3(Vector3 x) { memcpy(data, &x, sizeof(x)); }
 		void setColor(Color x)     { static_cast<Color*>(data)->setColor(&x); }
+        
+        void setParamValueFromString(int type, String pvalue);
 	};	
 	
 	class RenderTargetBinding : public PolyBase {

Core/Contents/Source/PolyEntity.cpp

@@ -590,12 +590,14 @@ void Entity::setRotationQuat(Number w, Number x, Number y, Number z) {
 	rotationQuat.y = y;
 	rotationQuat.z = z;
     rotation = rotationQuat.toEulerAngles();
+    rotation = rotation * TODEGREES;
 	matrixDirty = true;
 }
 
 void Entity::setRotationByQuaternion(const Quaternion &quaternion) {
 	rotationQuat = quaternion;
     rotation = quaternion.toEulerAngles();
+    rotation = rotation * TODEGREES;
 	matrixDirty = true;
 }
 

Core/Contents/Source/PolyGLCubemap.cpp

@@ -51,23 +51,34 @@ void OpenGLCubemap::recreateFromTextures() {
 	Texture *tex;
 	
 	tex = getTexture(Cubemap::CUBEMAP_XPOS);
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-
-	tex = getTexture(Cubemap::CUBEMAP_XNEG);	
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+    }
+    
+	tex = getTexture(Cubemap::CUBEMAP_XNEG);
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+    }
+    
 	tex = getTexture(Cubemap::CUBEMAP_YPOS);
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+    }
+    
 	tex = getTexture(Cubemap::CUBEMAP_YNEG);
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+    }
+    
 	tex = getTexture(Cubemap::CUBEMAP_ZPOS);
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+    }
+    
 	tex = getTexture(Cubemap::CUBEMAP_ZNEG);
-	glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-	
+    if(tex) {
+        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
+	}
 		
 	glCubemapLoaded = true;
 }

Core/Contents/Source/PolyMaterialManager.cpp

@@ -488,50 +488,12 @@ Material *MaterialManager::materialFromXMLNode(TiXmlNode *node) {
 								String pname =  pChild2Element->Attribute("name");
 								
 								if(!CoreServices::getInstance()->getRenderer()->getDataPointerForName(pname)) {								
-								String pvalue =  pChild2Element->Attribute("value");																
-								int type = materialShader->getExpectedParamType(pname);								
-								LocalShaderParam *param = newShaderBinding->addParam(type, pname);
-								
-								
-								if(param) {
-									switch(type) {
-										case ProgramParam::PARAM_NUMBER:
-										{
-											param->setNumber(atof(pvalue.c_str()));
-										}
-										break;
-										case ProgramParam::PARAM_VECTOR2:
-										{
-											std::vector<String> values = pvalue.split(" ");
-											if(values.size() == 2) {
-												param->setVector2(Vector2(atof(values[0].c_str()), atof(values[1].c_str())));
-											} else {
-												printf("Material parameter error: A Vector2 must have 2 values (%d provided)!\n", (int)values.size());
-											}
-										}											
-										break;
-										case ProgramParam::PARAM_VECTOR3:
-										{
-											std::vector<String> values = pvalue.split(" ");
-											if(values.size() == 3) {
-												param->setVector3(Vector3(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str())));
-											} else {
-												printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
-											}
-										}										
-										break;
-										case ProgramParam::PARAM_COLOR:
-										{
-											std::vector<String> values = pvalue.split(" ");
-											if(values.size() == 4) {
-												param->setColor(Color(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()), atof(values[3].c_str())));
-											} else {
-												printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
-											}
-										}										
-										break;										
-									}
-									}
+                                    String pvalue =  pChild2Element->Attribute("value");
+                                    int type = materialShader->getExpectedParamType(pname);
+                                    LocalShaderParam *param = newShaderBinding->addParam(type, pname);
+                                    if(param) {
+                                        param->setParamValueFromString(type, pvalue);
+                                    }
 								}
 							}						
 						}

Core/Contents/Source/PolySceneEntityInstance.cpp

@@ -24,6 +24,9 @@
 #include "PolyLogger.h"
 #include "PolyCoreServices.h"
 #include "PolyResourceManager.h"
+#include "PolyMaterial.h"
+#include "PolySceneLight.h"
+#include "PolySceneMesh.h"
 
 using namespace Polycode;
 
@@ -48,7 +51,8 @@ SceneEntityInstance *SceneEntityInstance::BlankSceneEntityInstance() {
 	return new SceneEntityInstance();
 }
 
-SceneEntityInstance::SceneEntityInstance(const String& fileName) : Entity() {
+SceneEntityInstance::SceneEntityInstance(Scene *parentScene, const String& fileName) : Entity() {
+    this->parentScene = parentScene;
 	resourceEntry = new SceneEntityInstanceResourceEntry(this);		
 	loadFromFile(fileName);
 	resourceEntry->setResourceName(fileName);
@@ -79,7 +83,7 @@ SceneEntityInstanceResourceEntry *SceneEntityInstance::getResourceEntry() {
 Entity *SceneEntityInstance::Clone(bool deepClone, bool ignoreEditorOnly) const {
 	SceneEntityInstance *newEntity;
 	if(cloneUsingReload) {
-		newEntity = new SceneEntityInstance(fileName);
+		newEntity = new SceneEntityInstance(parentScene, fileName);
 	} else {
 		newEntity = new SceneEntityInstance();
 	}
@@ -97,30 +101,70 @@ void SceneEntityInstance::applyClone(Entity *clone, bool deepClone, bool ignoreE
 	}
 }
 
-void SceneEntityInstance::applyScenePrimitive(ObjectEntry *entry, ScenePrimitive *primitive) {
-	if(!entry) 
+void SceneEntityInstance::applySceneMesh(ObjectEntry *entry, SceneMesh *sceneMesh) {
+	if(!entry) {
 		return;
-/*		
-	Number swidth = (*entry)["width"]->NumberVal;
-	Number sheight = (*entry)["height"]->NumberVal;
-	int type = (*entry)["type"]->intVal;
-	
-	shape->setShapeType(type);
-	shape->setShapeSize(swidth, sheight);
-
-	Number strokeColorR = (*entry)["strokeColorR"]->NumberVal;
-	Number strokeColorG = (*entry)["strokeColorG"]->NumberVal;
-	Number strokeColorB = (*entry)["strokeColorB"]->NumberVal;
-	Number strokeColorA = (*entry)["strokeColorA"]->NumberVal;
-
-	bool strokeEnabled = (*entry)["strokeEnabled"]->boolVal;					
-	Number strokeWidth = (*entry)["strokeWidth"]->NumberVal;
-	
-	shape->strokeEnabled = strokeEnabled;
-	shape->strokeWidth = strokeWidth;
-	shape->strokeColor = Color(strokeColorR, strokeColorG, strokeColorB, strokeColorA);
-	
-	*/
+    }
+    
+    ObjectEntry *materialName =(*entry)["material"];
+    if(materialName) {
+        sceneMesh->setMaterialByName(materialName->stringVal);
+        if(sceneMesh->getMaterial()) {
+            ObjectEntry *optionsEntry =(*entry)["shader_options"];
+            if(optionsEntry) {
+                for(int i=0; i < optionsEntry->length; i++) {
+                    ObjectEntry *shaderEntry =(*optionsEntry)[i];
+                    if(shaderEntry) {
+                        
+                        // parse in texture bindings
+                        ObjectEntry *texturesEntry =(*shaderEntry)["textures"];
+                        if(texturesEntry) {
+                            for(int j=0; j < texturesEntry->length; j++) {
+                                ObjectEntry *textureEntry =(*texturesEntry)[j];
+                                if(textureEntry) {
+                                    ObjectEntry *nameEntry = (*textureEntry)["name"];
+                                    if(nameEntry) {
+                                        
+                                        if(textureEntry->name == "cubemap") {
+                                            Cubemap *cubemap = (Cubemap*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_CUBEMAP, textureEntry->stringVal);
+                                            if(cubemap) {
+                                                sceneMesh->getLocalShaderOptions()->addCubemap(nameEntry->stringVal, cubemap);
+                                            }
+                                        } else {
+                                            sceneMesh->getLocalShaderOptions()->addTexture(nameEntry->stringVal, CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(textureEntry->stringVal));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        
+                        ObjectEntry *paramsEntry =(*shaderEntry)["params"];
+                        if(paramsEntry) {
+                            for(int j=0; j < paramsEntry->length; j++) {
+                                ObjectEntry *paramEntry =(*paramsEntry)[j];
+                                if(paramEntry) {
+                                    ObjectEntry *nameEntry = (*paramEntry)["name"];
+                                    ObjectEntry *valueEntry = (*paramEntry)["value"];
+                                    if(nameEntry && valueEntry) {
+                                        Shader *materialShader = sceneMesh->getMaterial()->getShader(i);
+                                        if(materialShader) {
+                                            int type = materialShader->getExpectedParamType(nameEntry->stringVal);
+                                            LocalShaderParam *param = sceneMesh->getLocalShaderOptions()->addParam(type, nameEntry->stringVal);
+                                            if(param) {
+                                                param->setParamValueFromString(type, valueEntry->stringVal);
+                                            }
+                                        }
+                                    }
+                                    
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
 }
 
 void SceneEntityInstance::parseObjectIntoCurve(ObjectEntry *entry, BezierCurve *curve) {
@@ -162,87 +206,83 @@ void SceneEntityInstance::parseObjectIntoCurve(ObjectEntry *entry, BezierCurve *
 Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entity *targetEntity) {
 
 	Entity *entity = NULL;
-/*	
+
 	ObjectEntry *entityType = (*entry)["type"];
 	if(entityType) {
-	
-		if(entityType->stringVal == "ScreenImage") {
-			ObjectEntry *screenImageEntry = (*entry)["ScreenImage"];			
-			String imagePath = (*screenImageEntry)["filePath"]->stringVal;
-			ScreenImage *image = new ScreenImage(imagePath);
-			
-			ObjectEntry *screenShapeEntry = (*entry)["ScreenShape"];
-			applyScreenShape(screenShapeEntry, image);
-			entity = image;
-		}
-		
-		if(entityType->stringVal == "ScreenParticleEmitter") {
-			ObjectEntry *emitterEntry = (*entry)["ScreenParticleEmitter"];
-									
-			ScreenParticleEmitter *placingEmitter = new ScreenParticleEmitter((*emitterEntry)["texturePath"]->stringVal, Particle::BILLBOARD_PARTICLE, ParticleEmitter::CONTINUOUS_EMITTER, (*emitterEntry)["lifespan"]->NumberVal, (*emitterEntry)["particleCount"]->NumberVal, Vector3((*emitterEntry)["dirX"]->NumberVal, (*emitterEntry)["dirY"]->NumberVal, 0.0), Vector3((*emitterEntry)["gravX"]->NumberVal, (*emitterEntry)["gravY"]->NumberVal, 0.0), Vector3((*emitterEntry)["deviationX"]->NumberVal, (*emitterEntry)["deviationY"]->NumberVal, 0.0), Vector3((*emitterEntry)["radiusX"]->NumberVal, (*emitterEntry)["radiusY"]->NumberVal, 0.0));
 			
-				placingEmitter->brightnessDeviation = (*emitterEntry)["brightnessDeviation"]->NumberVal;
-				placingEmitter->particleSize = (*emitterEntry)["particleSize"]->NumberVal;
-				placingEmitter->perlinModSize = (*emitterEntry)["perlinModSize"]->NumberVal;
-				placingEmitter->perlinEnabled = (*emitterEntry)["perlinEnabled"]->boolVal;
-				placingEmitter->particleSpeedMod = (*emitterEntry)["particleSpeedMod"]->NumberVal;
-
-				placingEmitter->rotationSpeed = (*emitterEntry)["rotationSpeed"]->NumberVal;
-				placingEmitter->rotationFollowsPath = (*emitterEntry)["rotationFollowsPath"]->boolVal;
-				placingEmitter->useScaleCurves = (*emitterEntry)["useScaleCurves"]->boolVal;
-				placingEmitter->useColorCurves = (*emitterEntry)["useColorCurves"]->boolVal;
-				
-				bool boolVal;
-				if(emitterEntry->readBool("ignoreParentMatrix", &boolVal)) {
-					placingEmitter->setIgnoreParentMatrix(boolVal);
-				}
-									
-				placingEmitter->setParticleBlendingMode((*emitterEntry)["particleBlendMode"]->intVal);			
-				
-				placingEmitter->setWidth(placingEmitter->emitterRadius.x);
-				placingEmitter->setHeight(placingEmitter->emitterRadius.y);	
-				
-				parseObjectIntoCurve((*emitterEntry)["scaleCurve"], &placingEmitter->scaleCurve);
-				parseObjectIntoCurve((*emitterEntry)["colorCurveR"], &placingEmitter->colorCurveR);
-				parseObjectIntoCurve((*emitterEntry)["colorCurveG"], &placingEmitter->colorCurveG);
-				parseObjectIntoCurve((*emitterEntry)["colorCurveB"], &placingEmitter->colorCurveB);
-				parseObjectIntoCurve((*emitterEntry)["colorCurveA"], &placingEmitter->colorCurveA);										
+        
+        /*
+         
+         if(entityType->stringVal == "SceneEntityInstance") {
+         ObjectEntry *screenInstanceEntry = (*entry)["SceneEntityInstance"];
+         String filePath = (*screenInstanceEntry)["filePath"]->stringVal;
+         SceneEntityInstance *instance = new SceneEntityInstance(filePath);
+         entity = instance;
+         }
+         
+         */
+
+		if(entityType->stringVal == "SceneSprite") {
+			ObjectEntry *spriteEntry = (*entry)["SceneSprite"];
+			String filePath = (*spriteEntry)["filePath"]->stringVal;
 			
-			entity = placingEmitter;
-		
-		}		
-
-		if(entityType->stringVal == "ScreenSprite") {
-			ObjectEntry *screenSpriteEntry = (*entry)["ScreenSprite"];			
-			String filePath = (*screenSpriteEntry)["filePath"]->stringVal;
+			SceneSprite *sprite = new SceneSprite(filePath);
 			
-			ScreenSprite *sprite = new ScreenSprite(filePath);
-			
-			String animName = (*screenSpriteEntry)["anim"]->stringVal;
+			String animName = (*spriteEntry)["anim"]->stringVal;
 			sprite->playAnimation(animName, -1, false);
-		
-
-			ObjectEntry *screenShapeEntry = (*entry)["ScreenShape"];
-			applyScreenShape(screenShapeEntry, sprite);
 			entity = sprite;
-		}
-
-
-		if(entityType->stringVal == "SceneEntityInstance") {
-			ObjectEntry *screenInstanceEntry = (*entry)["SceneEntityInstance"];
-			String filePath = (*screenInstanceEntry)["filePath"]->stringVal;
-			SceneEntityInstance *instance = new SceneEntityInstance(filePath);			
-			entity = instance;
-		}
-		
-
-		if(entityType->stringVal == "ScreenShape") {
-			ObjectEntry *screenShapeEntry = (*entry)["ScreenShape"];
-			ScreenShape *shape = new ScreenShape(0, 1, 1);
-			applyScreenShape(screenShapeEntry, shape);
-			entity = shape;
-		}
-		
+            applySceneMesh((*entry)["SceneMesh"], sprite);
+		} 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);
+                
+                newLight->lightColor.setColor((*lightEntry)["cR"]->NumberVal, (*lightEntry)["cG"]->NumberVal, (*lightEntry)["cB"]->NumberVal, (*lightEntry)["cA"]->NumberVal);
+                newLight->specularLightColor.setColor((*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);
+                    entity = newMesh;
+                }
+            }
+        }
+/*
 		if(entityType->stringVal == "ScreenSound") {
 			ObjectEntry *screenSoundEntry = (*entry)["ScreenSound"];
 			
@@ -261,7 +301,7 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
 										
 			entity = sound;
 		}		
-		
+
 
 		if(entityType->stringVal == "ScreenLabel") {
 			ObjectEntry *screenLabelEntry = (*entry)["ScreenLabel"];
@@ -278,53 +318,35 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
 			applyScreenShape(screenShapeEntry, label);
 			entity = label;
 		}
-	
+			*/
 	} 
 
 	if(!entity) {
 		if(targetEntity) {
 			entity = targetEntity;
 		} else {
-			entity = new ScreenEntity();
+			entity = new Entity();
 		}
 	}
 	
 	entity->ownsChildren = true;
-	
-	if((*entry)["positionMode"]) {
-		entity->setPositionMode((*entry)["positionMode"]->intVal);
-	} else {
-		entity->setPositionMode(ScreenEntity::POSITION_CENTER);
-	}
 
-	Number _width, _height;
-	
-	if(entry->readNumber("width", &_width)) {
-		entity->setWidth(_width);	
-	}
-	
-	if(entry->readNumber("height", &_height)) {
-		entity->setHeight(_height);	
-	}
+	entry->readNumber("bbX", &entity->bBox.x);
+	entry->readNumber("bbY", &entity->bBox.y);
+	entry->readNumber("bbZ", &entity->bBox.z);
 
-	entity->color.r = (*entry)["colorR"]->NumberVal;
-	entity->color.g = (*entry)["colorG"]->NumberVal;
-	entity->color.b = (*entry)["colorB"]->NumberVal;
-	entity->color.a = (*entry)["colorA"]->NumberVal;
+	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->blendingMode = (*entry)["blendMode"]->intVal;
 
-		entity->scale.x = (*entry)["scaleX"]->NumberVal;
-		entity->scale.y = (*entry)["scaleY"]->NumberVal;
-
-		entity->position.x = (*entry)["posX"]->NumberVal;
-		entity->position.y = (*entry)["posY"]->NumberVal;
-
-		entity->setRotation((*entry)["rotation"]->NumberVal);
-	} else {
-	
+        entity->setScale((*entry)["sX"]->NumberVal, (*entry)["sY"]->NumberVal, (*entry)["sZ"]->NumberVal);
+        entity->setPosition((*entry)["pX"]->NumberVal, (*entry)["pY"]->NumberVal, (*entry)["pZ"]->NumberVal);
+        entity->setRotationEuler(Vector3((*entry)["rX"]->NumberVal, (*entry)["rY"]->NumberVal, (*entry)["rZ"]->NumberVal));
 	}
 	
 	if((*entry)["id"]->stringVal != "") {
@@ -359,7 +381,7 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
 			entity->addChild(childEntity);				
 		}
 	}
-	*/	
+
 	return entity;
 }
 
@@ -385,7 +407,9 @@ bool SceneEntityInstance::loadFromFile(const String& fileName) {
 	this->fileName = fileName;
 	Object loadObject;
 	if(!loadObject.loadFromBinary(fileName)) {
-		Logger::log("Error loading entity instance.\n");
+        if(!loadObject.loadFromXML(fileName)) {
+            Logger::log("Error loading entity instance.\n");
+        }
 	}	
 	ObjectEntry *root = loadObject.root["root"];
 	

Core/Contents/Source/PolySceneLight.cpp

@@ -85,6 +85,7 @@ void SceneLight::enableShadows(bool val, unsigned int resolution) {
         CoreServices::getInstance()->getRenderer()->createRenderTextures(NULL, &zBufferTexture, resolution, resolution, false);
 		if(!spotCamera) {
 			spotCamera = new Camera(parentScene);
+            spotCamera->editorOnly = true;
 //			spotCamera->setPitch(-45.0f);
 			addChild(spotCamera);	
 		}

Core/Contents/Source/PolySceneMesh.cpp

@@ -44,9 +44,7 @@ SceneMesh *SceneMesh::SceneMeshWithType(int meshType) {
 }
 
 SceneMesh::SceneMesh(const String& fileName) : Entity(), texture(NULL), material(NULL), skeleton(NULL), localShaderOptions(NULL) {
-	mesh = new Mesh(fileName);
-	bBoxRadius = mesh->getRadius();
-	bBox = mesh->calculateBBox();
+    loadFromFile(fileName);
 	lightmapIndex=0;
 	showVertexNormals = false;
 	useVertexBuffer = false;
@@ -109,6 +107,17 @@ SceneMesh::~SceneMesh() {
 	delete localShaderOptions;
 }
 
+void SceneMesh::loadFromFile(String fileName) {
+	mesh = new Mesh(fileName);
+	bBoxRadius = mesh->getRadius();
+	bBox = mesh->calculateBBox();
+    this->fileName = fileName;
+}
+
+String SceneMesh::getFilename() {
+    return fileName;
+}
+
 Mesh *SceneMesh::getMesh() {
 	return mesh;
 }

Core/Contents/Source/PolyShader.cpp

@@ -104,6 +104,7 @@ unsigned int ShaderBinding::getNumLocalParams() {
 	return localParams.size();
 }
 
+
 LocalShaderParam *ShaderBinding::getLocalParam(unsigned int index) {
 	return localParams[index];
 }
@@ -261,3 +262,49 @@ void Shader::setName(const String& name) {
 const String& Shader::getName() const {
 	return name;
 }
+
+LocalShaderParam::LocalShaderParam() {
+    data = NULL;
+}
+
+void LocalShaderParam::setParamValueFromString(int type, String pvalue) {
+        switch(type) {
+            case ProgramParam::PARAM_NUMBER:
+            {
+                setNumber(atof(pvalue.c_str()));
+            }
+                break;
+            case ProgramParam::PARAM_VECTOR2:
+            {
+                std::vector<String> values = pvalue.split(" ");
+                if(values.size() == 2) {
+                    setVector2(Vector2(atof(values[0].c_str()), atof(values[1].c_str())));
+                } else {
+                    printf("Material parameter error: A Vector2 must have 2 values (%d provided)!\n", (int)values.size());
+                }
+            }
+                break;
+            case ProgramParam::PARAM_VECTOR3:
+            {
+                std::vector<String> values = pvalue.split(" ");
+                if(values.size() == 3) {
+                    setVector3(Vector3(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str())));
+                } else {
+                    printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
+                }
+            }
+                break;
+            case ProgramParam::PARAM_COLOR:
+            {
+                std::vector<String> values = pvalue.split(" ");
+                if(values.size() == 4) {
+                    setColor(Color(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()), atof(values[3].c_str())));
+                } else {
+                    printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
+                }
+            }
+                break;
+        }
+    
+    return false;
+}

IDE/Contents/Include/PolycodeEntityEditor.h

@@ -99,6 +99,13 @@ class EntityEditorMainView : public UIElement {
             void setEditorMode(int newMode);
             Entity *getSelectedEntity();
     
+            Entity *getObjectRoot();
+            void setObjectRoot(Entity *entity);
+    
+            Scene *getMainScene();
+    
+            void setEditorPropsRecursive(Entity *entity);
+    
             static const int EDITOR_MODE_3D = 0;
             static const int EDITOR_MODE_2D = 1;
     
@@ -148,6 +155,10 @@ class PolycodeEntityEditor : public PolycodeEditor {
     
         void Activate();
         void saveFile();
+        void saveCurveToObject(ObjectEntry *entry, BezierCurve *curve);
+        void saveShaderOptionsToEntry(ObjectEntry *entry, Material *material, ShaderBinding *binding);
+    
+        void saveEntityToObjectEntry(Entity *entity, ObjectEntry *entry);
     
 		
         void handleEvent(Event *event);

IDE/Contents/Include/PolycodeMaterialEditor.h

@@ -302,7 +302,7 @@ class PolycodeMaterialEditor : public PolycodeEditor {
 	void saveFile();
 	void saveMaterials(ObjectEntry *materialsEntry, std::vector<Material*> materials);
 	
-	String createStringValue(unsigned int type, void *value);
+	static String createStringValue(unsigned int type, void *value);
 	
 	protected:
 		UIImage *editorImage;

IDE/Contents/Source/PolycodeEntityEditor.cpp

@@ -22,12 +22,15 @@
  
 #include "PolycodeEntityEditor.h"
 #include "PolycodeFrame.h"
+#include "PolyCubemap.h"
+#include "PolycodeMaterialEditor.h"
 
 extern UIGlobalMenu *globalMenu;
 extern PolycodeFrame *globalFrame;
 extern Scene *globalScene;
 
-LightDisplay::LightDisplay(SceneLight *light) {
+LightDisplay::LightDisplay(SceneLight *light) : Entity() {
+    editorOnly = true;
     this->light = light;
     spotSpot = new ScenePrimitive(ScenePrimitive::TYPE_LINE_CIRCLE, 1.0, 1.0, 32);
 	spotSpot->getMesh()->setMeshType(Mesh::LINE_LOOP_MESH);
@@ -357,6 +360,13 @@ void EntityEditorMainView::createIcon(Entity *entity, String iconFile) {
     icons.push_back(iconPrimitive);
 }
 
+void EntityEditorMainView::setEditorPropsRecursive(Entity *entity) {
+    setEditorProps(entity);
+    for(int i=0; i < entity->getNumChildren(); i++) {
+        setEditorProps(entity->getChildAtIndex(i));
+    }
+}
+
 void EntityEditorMainView::setEditorProps(Entity *entity) {
     entity->processInputEvents = true;
     entity->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
@@ -620,6 +630,10 @@ void EntityEditorMainView::handleEvent(Event *event) {
     }
 }
 
+Scene *EntityEditorMainView::getMainScene() {
+    return mainScene;
+}
+
 void EntityEditorMainView::doEntityDeselect(Entity *targetEntity) {
     SceneMesh *sceneMesh = dynamic_cast<SceneMesh*>(targetEntity);
     if(sceneMesh) {
@@ -669,6 +683,21 @@ void EntityEditorMainView::selectEntity(Entity *targetEntity, bool addToSelectio
     
 }
 
+Entity *EntityEditorMainView::getObjectRoot() {
+    return sceneObjectRoot;
+}
+
+void EntityEditorMainView::setObjectRoot(Entity *entity) {
+    if(sceneObjectRoot) {
+        sceneObjectRoot->getParentEntity()->removeChild(sceneObjectRoot);
+        delete sceneObjectRoot;
+    }
+    sceneObjectRoot = entity;
+    sceneObjectRoot->processInputEvents = true;
+    mainScene->addChild(sceneObjectRoot);
+    sceneObjectRoot->getParentEntity()->moveChildBottom(sceneObjectRoot);
+}
+
 EntityEditorMainView::~EntityEditorMainView() {
 	
 }
@@ -726,7 +755,12 @@ PolycodeEntityEditor::~PolycodeEntityEditor() {
 }
 
 bool PolycodeEntityEditor::openFile(OSFileEntry filePath) {	
-	PolycodeEditor::openFile(filePath);	
+	PolycodeEditor::openFile(filePath);
+//    return true;
+    SceneEntityInstance *loadedInstance = new SceneEntityInstance(mainView->getMainScene(), filePath.fullPath);
+    mainView->setObjectRoot(loadedInstance);
+    mainView->setEditorPropsRecursive(loadedInstance);
+    
 	return true;
 }
 
@@ -734,8 +768,285 @@ void PolycodeEntityEditor::Activate() {
     Resize(getWidth(), getHeight());
 }
 
+void PolycodeEntityEditor::saveCurveToObject(ObjectEntry *entry, BezierCurve *curve) {
+    ObjectEntry *controlPoints = entry->addChild("controlPoints");
+    
+    for(int i=0; i < curve->getNumControlPoints(); i++) {
+        ObjectEntry *controlPointEntry = controlPoints->addChild("controlPoint");
+        ObjectEntry *pt1 = controlPointEntry->addChild("pt1");
+        pt1->addChild("x", curve->getControlPoint(i)->p1.x);
+        pt1->addChild("y", curve->getControlPoint(i)->p1.y);
+        pt1->addChild("z", curve->getControlPoint(i)->p1.z);
+        
+        ObjectEntry *pt2 = controlPointEntry->addChild("pt2");
+        pt2->addChild("x", curve->getControlPoint(i)->p2.x);
+        pt2->addChild("y", curve->getControlPoint(i)->p2.y);
+        pt2->addChild("z", curve->getControlPoint(i)->p2.z);
+        
+        ObjectEntry *pt3 = controlPointEntry->addChild("pt3");
+        pt3->addChild("x", curve->getControlPoint(i)->p3.x);
+        pt3->addChild("y", curve->getControlPoint(i)->p3.y);
+        pt3->addChild("z", curve->getControlPoint(i)->p3.z);
+    }
+}
+
+void PolycodeEntityEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *entry) {
+    if(entity->editorOnly)
+        return;
+    
+    entry->addChild("id", entity->id);
+    
+    String tagString = "";
+    for(int i=0; i < entity->getNumTags(); i++) {
+        if(i != 0) {
+            tagString += ",";
+        }
+        tagString += entity->getTagAtIndex(i);
+    }
+    entry->addChild("tags", tagString);
+
+    
+    if(entity->entityProps.size() > 0) {
+        ObjectEntry *props = entry->addChild("props");
+        for(int i=0; i < entity->entityProps.size(); i++) {
+            ObjectEntry *prop = props->addChild("prop");
+            prop->addChild("name", entity->entityProps[i].propName);
+            prop->addChild("value", entity->entityProps[i].propValue);
+        }
+    }
+    
+    if(dynamic_cast<SceneEntityInstance*>(entity)) {
+        if(!(*(entry))["type"]) {
+            entry->addChild("type", "SceneEntityInstance");
+        }
+        SceneEntityInstance *instance = (SceneEntityInstance*) entity;
+        ObjectEntry *instanceEntry = entry->addChild("SceneEntityInstance");
+        instanceEntry->addChild("filePath", instance->getFileName());
+    }
+    
+    if(dynamic_cast<SceneParticleEmitter*>(entity)) {
+        if(!(*(entry))["type"])
+            entry->addChild("type", "SceneParticleEmitter");
+        
+        SceneParticleEmitter *emitter = (SceneParticleEmitter*) entity;
+        
+        ObjectEntry *emitterEntry = entry->addChild("SceneParticleEmitter");
+//        emitterEntry->addChild("radiusX", emitter->emitterRadius.x);
+     
+        
+        saveCurveToObject(emitterEntry->addChild("scaleCurve"), &emitter->scaleCurve);
+        
+        saveCurveToObject(emitterEntry->addChild("colorCurveR"), &emitter->colorCurveR);
+        saveCurveToObject(emitterEntry->addChild("colorCurveG"), &emitter->colorCurveG);
+        saveCurveToObject(emitterEntry->addChild("colorCurveB"), &emitter->colorCurveB);
+        saveCurveToObject(emitterEntry->addChild("colorCurveA"), &emitter->colorCurveA);
+        
+    }
+    
+    if(dynamic_cast<SceneSprite*>(entity)) {
+        if(!(*(entry))["type"])
+            entry->addChild("type", "SceneSprite");
+        SceneSprite *sprite = (SceneSprite*) entity;
+        
+        ObjectEntry *spriteEntry = entry->addChild("SceneSprite");
+        spriteEntry->addChild("filePath", sprite->getFileName());
+        
+        String animName = "";
+        if(sprite->getCurrentAnimation()) {
+            animName = sprite->getCurrentAnimation()->name;
+        }
+        spriteEntry->addChild("anim", animName);
+    }
+    
+    if(dynamic_cast<SceneLabel*>(entity)) {
+        SceneLabel *label = (SceneLabel*) entity;
+        
+        if(!(*(entry))["type"])
+            entry->addChild("type", "SceneLabel");
+        ObjectEntry *labelEntry = entry->addChild("SceneLabel");
+        labelEntry->addChild("text", label->getText());
+        labelEntry->addChild("font", label->getLabel()->getFont()->getFontName());
+        labelEntry->addChild("size", (int)label->getLabel()->getSize());
+        labelEntry->addChild("aaMode", (int)label->getLabel()->getAntialiasMode());
+    }
+    
+    if(dynamic_cast<SceneLight*>(entity)) {
+        SceneLight *light = (SceneLight*) entity;
+        if(!(*(entry))["type"]) {
+            entry->addChild("type", "SceneLight");
+        }
+        
+        ObjectEntry *lightEntry = entry->addChild("SceneLight");
+        lightEntry->addChild("type", light->getType());
+
+        lightEntry->addChild("cR", light->lightColor.r);
+        lightEntry->addChild("cG", light->lightColor.g);
+        lightEntry->addChild("cB", light->lightColor.b);
+        lightEntry->addChild("cA", light->lightColor.a);
+
+        lightEntry->addChild("scR", light->specularLightColor.r);
+        lightEntry->addChild("scG", light->specularLightColor.g);
+        lightEntry->addChild("scB", light->specularLightColor.b);
+        lightEntry->addChild("scA", light->specularLightColor.a);
+
+        lightEntry->addChild("intensity", light->getIntensity());
+
+        lightEntry->addChild("cAtt", light->getConstantAttenuation());
+        lightEntry->addChild("lAtt", light->getLinearAttenuation());
+        lightEntry->addChild("qAtt", light->getQuadraticAttenuation());
+
+        if(light->getType() == SceneLight::SPOT_LIGHT) {
+            lightEntry->addChild("spotCutoff", light->getSpotlightCutoff());
+            lightEntry->addChild("spotExponent", light->getSpotlightExponent());
+            lightEntry->addChild("shadows", light->areShadowsEnabled());
+            if(light->areShadowsEnabled()) {
+                lightEntry->addChild("shadowmapFOV", light->getShadowMapFOV());
+                lightEntry->addChild("shadowmapRes", (int)light->getShadowMapResolution());
+            }
+        }
+        
+    }
+    
+    
+    
+    if(dynamic_cast<SceneSound*>(entity)) {
+        SceneSound *sound = (SceneSound*) entity;
+        
+        if(!(*(entry))["type"]) {
+            entry->addChild("type", "SceneSound");
+        }
+        ObjectEntry *soundEntry = entry->addChild("SceneSound");
+        soundEntry->addChild("filePath", sound->getSound()->getFileName());
+        soundEntry->addChild("refDistance", sound->getSound()->getReferenceDistance());
+        soundEntry->addChild("maxDistance", sound->getSound()->getMaxDistance());
+        soundEntry->addChild("volume", sound->getSound()->getVolume());
+        soundEntry->addChild("pitch", sound->getSound()->getPitch());
+    }
+    
+    if(dynamic_cast<ScenePrimitive*>(entity) && !dynamic_cast<SceneSprite*>(entity)) {
+        if(!(*(entry))["type"]) {
+            entry->addChild("type", "ScenePrimitive");
+        }
+        ScenePrimitive *primitive = (ScenePrimitive*) entity;
+        ObjectEntry *primitiveEntry = entry->addChild("ScenePrimitive");
+        primitiveEntry->addChild("type", primitive->getPrimitiveType());
+        primitiveEntry->addChild("p1", primitive->getPrimitiveParameter1());
+        primitiveEntry->addChild("p2", primitive->getPrimitiveParameter2());
+        primitiveEntry->addChild("p3", primitive->getPrimitiveParameter3());
+        primitiveEntry->addChild("p4", primitive->getPrimitiveParameter4());
+        primitiveEntry->addChild("p5", primitive->getPrimitiveParameter5());
+    }
+    
+    if(dynamic_cast<SceneMesh*>(entity)) {
+        if(!(*(entry))["type"]) {
+            entry->addChild("type", "SceneMesh");
+        }
+        
+        SceneMesh *sceneMesh = (SceneMesh*) entity;
+        
+        ObjectEntry *meshEntry = entry->addChild("SceneMesh");
+        
+        if(sceneMesh->getFilename() != "") {
+            meshEntry->addChild("file", sceneMesh->getFilename().replace(parentProject->getRootFolder()+"/", ""));
+        }
+        
+        if(sceneMesh->getMaterial()) {
+            meshEntry->addChild("material", sceneMesh->getMaterial()->getResourceName());
+            ObjectEntry *shaderOptions = meshEntry->addChild("shader_options");
+            saveShaderOptionsToEntry(shaderOptions, sceneMesh->getMaterial(), sceneMesh->getLocalShaderOptions());
+        }
+    }
+    
+    if(!(*(entry))["type"])
+        entry->addChild("type", "Entity");
+    
+    entry->addChild("cR", entity->color.r);
+    entry->addChild("cG", entity->color.g);
+    entry->addChild("cB", entity->color.b);
+    entry->addChild("cA", entity->color.a);
+    entry->addChild("blendMode", entity->blendingMode);
+    
+    entry->addChild("sX", entity->getScale().x);
+    entry->addChild("sY", entity->getScale().y);
+    entry->addChild("sZ", entity->getScale().z);
+        
+    entry->addChild("rX", entity->getPitch());
+    entry->addChild("rY", entity->getYaw());
+    entry->addChild("rZ", entity->getRoll());
+    
+    entry->addChild("pX", entity->getPosition().x);
+    entry->addChild("pY", entity->getPosition().y);
+    entry->addChild("pZ", entity->getPosition().z);
+    
+    entry->addChild("bbX", entity->bBox.x);
+    entry->addChild("bbY", entity->bBox.y);
+    entry->addChild("bbZ", entity->bBox.z);
+    
+    ObjectEntry *children = NULL;
+    
+    for(int i=0; i < entity->getNumChildren(); i++) {
+        if(!entity->getChildAtIndex(i)->editorOnly) {
+            if(!children)
+                children = entry->addChild("children");
+            ObjectEntry *child = children->addChild("child");
+            saveEntityToObjectEntry((ScreenEntity*)entity->getChildAtIndex(i), child);
+        }
+    }
+}
+
+void PolycodeEntityEditor::saveShaderOptionsToEntry(ObjectEntry *entry, Material *material, ShaderBinding *binding) {
+
+	
+    if(material->getNumShaders() > 0) {
+        for(int s=0; s < material->getNumShaders(); s++) {
+            Shader *shader = material->getShader(s);
+            
+            ObjectEntry *shaderEntry = entry->addChild("shader");
+            ObjectEntry *texturesEntry = shaderEntry->addChild("textures");
+            
+            for(int j=0; j < shader->expectedTextures.size(); j++) {
+                Texture *texture = binding->getTexture(shader->expectedTextures[j]);
+                if(texture) {
+                    String texturePath = texture->getResourcePath();
+                    texturePath = texturePath.replace(parentProject->getRootFolder()+"/", "");
+                    ObjectEntry *textureEntry = texturesEntry->addChild("texture", texturePath);
+                    textureEntry->addChild("name", shader->expectedTextures[j]);
+                }
+            }
+            
+            for(int j=0; j < shader->expectedCubemaps.size(); j++) {
+                Cubemap *cubemap = binding->getCubemap(shader->expectedCubemaps[j]);
+                if(cubemap) {
+                    String cubemapName = cubemap->getResourceName();
+                    ObjectEntry *cubemapEntry = texturesEntry->addChild("cubemap", cubemapName);
+                    cubemapEntry->addChild("name", shader->expectedCubemaps[j]);
+                }
+            }
+            
+            
+            if(shader->expectedParams.size() > 0 || shader->expectedParams.size() > 0) {
+                ObjectEntry *paramsEntry = shaderEntry->addChild("params");
+                
+                for(int j=0; j < shader->expectedParams.size(); j++) {
+                    if(binding->getLocalParamByName(shader->expectedParams[j].name)) {
+                        ObjectEntry *paramEntry = paramsEntry->addChild("param");
+                        paramEntry->addChild("name", shader->expectedParams[j].name);
+                        paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(shader->expectedParams[j].type, binding->getLocalParamByName(shader->expectedParams[j].name)->data));
+                    }
+                }
+            }
+        }
+    }
+}
+
 void PolycodeEntityEditor::saveFile() {
+    Object saveObject;
     
+    saveObject.root.name = "entity";
+    ObjectEntry *children = saveObject.root.addChild("root");
+    saveEntityToObjectEntry(mainView->getObjectRoot(), children);
+    saveObject.saveToXML(filePath);
+    setHasChanges(false);
 }
 
 

IDE/Contents/Source/PolycodeMaterialEditor.cpp

@@ -1330,7 +1330,7 @@ void PolycodeMaterialEditor::saveMaterials(ObjectEntry *materialsEntry, std::vec
 						if(shaderBinding->getLocalParamByName(shader->expectedParams[j].name)) {
 							ObjectEntry *paramEntry = paramsEntry->addChild("param");
 							paramEntry->addChild("name", shader->expectedParams[j].name);
-							paramEntry->addChild("value", createStringValue(shader->expectedParams[j].type, shaderBinding->getLocalParamByName(shader->expectedParams[j].name)->data));
+							paramEntry->addChild("value", PolycodeMaterialEditor::createStringValue(shader->expectedParams[j].type, shaderBinding->getLocalParamByName(shader->expectedParams[j].name)->data));
 						}
 					}
 				}
@@ -1459,7 +1459,7 @@ void PolycodeMaterialEditor::handleEvent(Event *event) {
 		setHasChanges(true);
 		CoreServices::getInstance()->getResourceManager()->addResource(cubemap);
 	}	
-		
+
 	if(event->getDispatcher() == materialBrowser->removeButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
 
 				mainWindow->materialPane->enabled = false;

IDE/Contents/Source/PolycodeProps.cpp

@@ -1154,7 +1154,7 @@ String SceneSpriteProp::get() {
 }
 
 SceneEntityInstanceProp::SceneEntityInstanceProp(String caption) : PropProp(caption, "SceneEntityInstance"){
-	previewInstance = new SceneEntityInstance("default/default.entity2d");
+//	previewInstance = new SceneEntityInstance("default/default.entity");
 	previewInstance->setAnchorPoint(-1.0, -1.0, 0.0);
 	previewInstance->setPosition(2, 1);
 	propContents->addChild(previewInstance);
@@ -1203,7 +1203,7 @@ void SceneEntityInstanceProp::set(String fileName) {
 	if(fileName != previewInstance->getFileName()) {
 		propContents->removeChild(previewInstance);
 		delete previewInstance;
-		previewInstance = new SceneEntityInstance(fileName);
+//		previewInstance = new SceneEntityInstance(fileName);
 		previewInstance->setAnchorPoint(-1.0, -1.0, 0.0);
 		previewInstance->setPosition(2, 1);
 		
@@ -2198,8 +2198,8 @@ void TransformSheet::Update() {
     }
     
     if(entity->getEulerRotation() != lastRotation) {
-        rotationProp->set(entity->getEulerRotation() * TODEGREES);
-        lastRotation = entity->getEulerRotation() * TODEGREES;
+        rotationProp->set(entity->getEulerRotation());
+        lastRotation = entity->getEulerRotation();
     }
 }