Added SceneSprite and SceneEntityInstance, the IDE is running again (sort of)

Core/Contents/CMakeLists.txt

@@ -80,6 +80,8 @@ SET(polycore_SRCS
     Source/PolyClient.cpp
     Source/PolyServer.cpp
     Source/PolyRay.cpp
+    Source/PolySceneSprite.cpp
+    Source/PolySceneEntityInstance.cpp
 )
 
 SET(polycore_HDRS
@@ -164,6 +166,8 @@ SET(polycore_HDRS
     Include/PolyServer.h
     Include/PolyServerWorld.h
     Include/PolyRay.h
+    Include/PolySceneSprite.h
+    Include/PolySceneEntityInstance.h
 )
 
 SET(CMAKE_DEBUG_POSTFIX "_d")

Core/Contents/Include/PolySceneEntityInstance.h

@@ -0,0 +1,87 @@
+/*
+Copyright (C) 2013 by Ivan Safrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#pragma once
+#include "PolyGlobals.h"
+#include "PolyEntity.h"
+#include "PolyObject.h"
+#include "PolyParticleEmitter.h"
+#include "PolyParticle.h"
+#include "PolyScenePrimitive.h"
+#include "PolyResource.h"
+#include "PolySound.h"
+
+namespace Polycode {
+
+class SceneEntityInstanceResourceEntry;
+
+class SceneEntityInstance : public Entity {
+	public:
+		SceneEntityInstance(const String& fileName);
+		SceneEntityInstance();
+		
+		static SceneEntityInstance *BlankSceneEntityInstance();
+
+		virtual ~SceneEntityInstance();
+	
+		virtual Entity *Clone(bool deepClone, bool ignoreEditorOnly) const;
+		virtual void applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const;
+		
+		void reloadEntityInstance();
+
+		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);
+		
+		
+		SceneEntityInstanceResourceEntry *getResourceEntry();
+		
+		String getFileName() const;
+		
+		bool cloneUsingReload;
+
+		String fileName;
+		
+	protected:
+		
+		SceneEntityInstanceResourceEntry *resourceEntry;
+		
+};
+
+class SceneEntityInstanceResourceEntry : public Resource {
+	public:
+		SceneEntityInstanceResourceEntry(SceneEntityInstance *instance);
+		virtual ~SceneEntityInstanceResourceEntry();
+		
+		SceneEntityInstance *getInstance();
+		void reloadResource();
+		
+	protected:
+		SceneEntityInstance* instance;
+};
+
+
+}

Core/Contents/Include/PolySceneLine.h

@@ -23,16 +23,16 @@ THE SOFTWARE.
 #pragma once
 #include "PolyString.h"
 #include "PolyGlobals.h"
-#include "PolyEntity.h"
+#include "PolySceneMesh.h"
 #include "PolyCoreServices.h"
 #include "PolyMesh.h"
 
 namespace Polycode {
 
 	/**
-	* 3D line class. Can connect two Entity classes with a line.
+	* 3D line class. Can connect two SceneEntity classes with a line.
 	*/ 
-	class _PolyExport SceneLine : public Entity {
+	class _PolyExport SceneLine : public SceneMesh {
 		public:
 			/**
 			* Constructs the line with two taraget entities.
@@ -59,15 +59,13 @@ namespace Polycode {
 			
 			void setStart(Vector3 start);
 			void setEnd(Vector3 end);
-						
-			void Render();
 			
-			Number lineWidth;
-			bool lineSmooth;				
+			void Update();
+				
 			
 		protected:		
 		
-			Mesh *mesh;
+			void initLine();		
 			
 			Vector3 start;
 			Vector3 end;			

Core/Contents/Include/PolySceneMesh.h

@@ -154,6 +154,7 @@ namespace Polycode {
 			
 			bool showVertexNormals;
 	
+			void setLineWidth(Number newWidth);
 					
 			Number lineWidth;
 			bool lineSmooth;

Core/Contents/Include/PolySceneSprite.h

@@ -0,0 +1,169 @@
+/*
+Copyright (C) 2013 by Ivan Safrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#pragma once
+#include "PolyGlobals.h"
+#include "PolyScenePrimitive.h"
+#include <vector>
+
+namespace Polycode {
+
+class SceneSpriteResourceEntry;
+
+class _PolyExport SpriteAnimation {
+	public:
+		Number speed;
+		String name;
+		String frames;
+		int numFrames;
+		
+		int numFramesX;
+		int numFramesY;
+		Number spriteUVWidth;
+		Number spriteUVHeight;
+						
+		void setOffsetsFromFrameString(const String& frames);
+	
+		std::vector<Vector2> framesOffsets;
+};
+
+/**
+* Animated 2D image sprite. This screen entity can load spritesheet images and play back animations.
+*/
+class _PolyExport SceneSprite : public ScenePrimitive 
+{
+	public:
+	
+		/**
+		* Create a sprite from a sprite file format
+		* @param fileName Sprite file to load
+		*/
+		SceneSprite(const String& fileName);
+	
+		/**
+		* Create a sprite from a spritesheet image of specified size.
+		* @param fileName Image file to load spritesheet from.
+		* @param spriteWidth Pixel width of each sprite cell.
+		* @param spriteWidth Pixel height of each sprite cell.		
+		*/
+		SceneSprite(const String& fileName, Number spriteWidth, Number spriteHeight);
+		
+		/**
+		* Create a sprite from a spritesheet image of specified size.
+		* @param fileName Image file to load spritesheet from.
+		* @param spriteWidth Pixel width of each sprite cell.
+		* @param spriteWidth Pixel height of each sprite cell.		
+		*/		
+		static SceneSprite* SceneSpriteFromImageFile(const String& fileName, Number spriteWidth, Number spriteHeight);
+		
+		virtual ~SceneSprite();
+		
+		virtual Entity *Clone(bool deepClone, bool ignoreEditorOnly) const;
+		virtual void applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const;
+
+		/**
+		* Adds a new animation to the sprite. Animations are added by specifying a list of frame indexes and then can be played back by the specified name.
+		* @param name Name of the new animation.
+		* @param frames A comma separated list of frames indexes to include in the animation.
+		* @speed Speed at which to play back the animation.
+		* @return Returns newly added animation
+		*/
+		SpriteAnimation *addAnimation(const String& name, const String& frames, Number speed);
+		
+		/**
+		* Shows a specific frame of the current animation.
+		* @param frameIndex Frame index of the frame to show.
+		*/
+		void showFrame(unsigned int frameIndex);
+		
+		/**
+		* Play back a previously created animation by name.
+		* @param name Name of the animation to play.
+		* @param startFrame Starting frame for playback.
+		* @param once If true, only plays once, otherwise loops.
+		*/
+		void playAnimation(const String& name, int startFrame, bool once);
+		void Update();
+		
+		void setSpriteSize(const Number spriteWidth, const Number spriteHeight);
+	
+		Vector2 getSpriteSize();
+	
+		String getFileName() const;
+	
+		void recalculateSpriteDimensions();
+	
+		bool loadFromFile(const String& fileName);
+		
+		void reloadSprite();
+	
+		/**
+		* Pauses or unpauses the current sprite animation.
+		* @param val If true, pauses the current animation, if false, resumes playing it.
+		*/ 
+		void Pause(bool val);
+		
+		unsigned int getNumAnimations();		
+		SpriteAnimation *getAnimationAtIndex(unsigned int index);
+		
+		SpriteAnimation *getCurrentAnimation();
+		unsigned int getCurrentAnimationFrame();
+		bool isCurrentAnimationFinished();
+		
+		void updateSprite();
+		
+		SceneSpriteResourceEntry *getResourceEntry();
+		
+	protected:
+	
+		String fileName;
+		
+		bool paused;
+	
+		Number spriteWidth;
+		Number spriteHeight;
+			
+		bool playingOnce;
+		Number lastTick;
+		
+		SceneSpriteResourceEntry *resourceEntry;
+		
+		Number spriteUVWidth;
+		Number spriteUVHeight;
+		int currentFrame;
+		SpriteAnimation *currentAnimation;
+		
+		std::vector<SpriteAnimation*> animations;
+};
+
+class SceneSpriteResourceEntry : public Resource {
+	public:
+		SceneSpriteResourceEntry(SceneSprite *sprite);
+		virtual ~SceneSpriteResourceEntry();		
+		SceneSprite *getSprite();
+		void reloadResource();
+		
+	protected:
+		SceneSprite* sprite;
+};
+	
+}

Core/Contents/Include/Polycode.h

@@ -84,6 +84,8 @@
 #include "PolyServerWorld.h"
 #include "PolySocket.h"
 #include "PolyRay.h"
+#include "PolySceneSprite.h"
+#include "PolySceneEntityInstance.h"
 #include "PolyGlobals.h"
 
 #ifdef _WINDOWS

Core/Contents/Source/PolyEntity.cpp

@@ -889,13 +889,20 @@ MouseEventResult Entity::onMouseUp(const Ray &ray, int mouseButton, int timestam
 	ret.blocked = false;
 	
 	if(processInputEvents && enabled) {
+	
+		Vector3 localCoordinate = Vector3(ray.origin.x,ray.origin.y,0);
+		Matrix4 inverse = getConcatenatedMatrix().Inverse();
+		localCoordinate = inverse * localCoordinate;			
+	
+	
 		if(ray.boxIntersect(bBox, getAnchorAdjustedMatrix())) {
 			ret.hit = true;			
-			dispatchEvent(new InputEvent(Vector2(), timestamp), InputEvent::EVENT_MOUSEUP);
-						
+			dispatchEvent(new InputEvent(Vector2(localCoordinate.x, localCoordinate.y), timestamp), InputEvent::EVENT_MOUSEUP);
 			if(blockMouseInput) {
 				ret.blocked = true;
 			}
+		} else {
+			dispatchEvent(new InputEvent(Vector2(localCoordinate.x, localCoordinate.y), timestamp), InputEvent::EVENT_MOUSEUP_OUTSIDE);
 		}
 		
 		for(int i=0; i < children.size(); i++) {
@@ -917,12 +924,17 @@ MouseEventResult Entity::onMouseMove(const Ray &ray, int timestamp) {
 	ret.blocked = false;
 	
 	if(processInputEvents && enabled) {
+	
+		Vector3 localCoordinate = Vector3(ray.origin.x,ray.origin.y,0);
+		Matrix4 inverse = getConcatenatedMatrix().Inverse();
+		localCoordinate = inverse * localCoordinate;	
+	
 		if(ray.boxIntersect(bBox, getAnchorAdjustedMatrix())) {	
 			ret.hit = true;			
-			dispatchEvent(new InputEvent(Vector2(), timestamp), InputEvent::EVENT_MOUSEMOVE);
+			dispatchEvent(new InputEvent(Vector2(localCoordinate.x, localCoordinate.y), timestamp), InputEvent::EVENT_MOUSEMOVE);
 			
 			if(!mouseOver) {
-				dispatchEvent(new InputEvent(Vector2(), timestamp), InputEvent::EVENT_MOUSEOVER);
+				dispatchEvent(new InputEvent(Vector2(localCoordinate.x, localCoordinate.y), timestamp), InputEvent::EVENT_MOUSEOVER);
 				mouseOver = true;
 			}			
 			
@@ -931,7 +943,7 @@ MouseEventResult Entity::onMouseMove(const Ray &ray, int timestamp) {
 			}
 		} else {
 			if(mouseOver) {
-				dispatchEvent(new InputEvent(Vector2(), timestamp), InputEvent::EVENT_MOUSEOUT);
+				dispatchEvent(new InputEvent(Vector2(localCoordinate.x, localCoordinate.y), timestamp), InputEvent::EVENT_MOUSEOUT);
 				mouseOver = false;
 			}		
 		}

Core/Contents/Source/PolyMesh.cpp

@@ -794,8 +794,10 @@ namespace Polycode {
 					vector<Polygon*> connectedFaces = getConnectedFaces(v);
 					for(int k=0; k < connectedFaces.size(); k++) {					
 						normal += connectedFaces[k]->getFaceNormal();
-					}					
-					normal = normal / connectedFaces.size();
+					}
+					if(connectedFaces.size() > 0) {
+						normal = normal / connectedFaces.size();
+					}
 					normal.Normalize();
 					v->setNormal(normal.x, normal.y, normal.z);
 				}

Core/Contents/Source/PolySceneEntity.cpp

@@ -1,34 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolySceneEntity.h"
-
-using namespace Polycode;
-
-SceneEntity::SceneEntity() : Entity() {
-	castShadows = true;
-}
-
-SceneEntity::~SceneEntity() {
-	
-}
-

Core/Contents/Source/PolySceneEntityInstance.cpp

@@ -0,0 +1,397 @@
+/*
+ Copyright (C) 2011 by Ivan Safrin
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#include "PolySceneEntityInstance.h"
+#include "PolyLogger.h"
+#include "PolyCoreServices.h"
+#include "PolyResourceManager.h"
+
+using namespace Polycode;
+
+SceneEntityInstanceResourceEntry::SceneEntityInstanceResourceEntry(SceneEntityInstance *instance)  : Resource(Resource::RESOURCE_SCREEN_ENTITY_INSTANCE) {
+	this->instance = instance;
+}
+
+SceneEntityInstanceResourceEntry::~SceneEntityInstanceResourceEntry() {
+
+}
+
+SceneEntityInstance *SceneEntityInstanceResourceEntry::getInstance() {
+	return instance;
+}
+
+void SceneEntityInstanceResourceEntry::reloadResource() {
+	instance->reloadEntityInstance();
+	Resource::reloadResource();
+}
+
+SceneEntityInstance *SceneEntityInstance::BlankSceneEntityInstance() {
+	return new SceneEntityInstance();
+}
+
+SceneEntityInstance::SceneEntityInstance(const String& fileName) : Entity() {
+	resourceEntry = new SceneEntityInstanceResourceEntry(this);		
+	loadFromFile(fileName);
+	resourceEntry->setResourceName(fileName);
+	resourceEntry->setResourcePath(fileName);
+	cloneUsingReload = false;
+	ownsChildren = true;	
+}
+
+SceneEntityInstance::SceneEntityInstance() : Entity() {
+	cloneUsingReload = true;
+	ownsChildren = true;
+	resourceEntry = new SceneEntityInstanceResourceEntry(this);
+}
+
+SceneEntityInstance::~SceneEntityInstance() {	
+	CoreServices::getInstance()->getResourceManager()->removeResource(resourceEntry);
+	delete resourceEntry;
+}
+
+void SceneEntityInstance::reloadEntityInstance() {
+	loadFromFile(fileName);
+}
+
+SceneEntityInstanceResourceEntry *SceneEntityInstance::getResourceEntry() {
+	return resourceEntry;
+}
+
+Entity *SceneEntityInstance::Clone(bool deepClone, bool ignoreEditorOnly) const {
+	SceneEntityInstance *newEntity;
+	if(cloneUsingReload) {
+		newEntity = new SceneEntityInstance(fileName);
+	} else {
+		newEntity = new SceneEntityInstance();
+	}
+	applyClone(newEntity, deepClone, ignoreEditorOnly);
+	return newEntity;
+}
+
+void SceneEntityInstance::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const {
+	if(cloneUsingReload) {
+		Entity::applyClone(clone, false, ignoreEditorOnly);
+	} else {
+		Entity::applyClone(clone, deepClone, ignoreEditorOnly);
+		SceneEntityInstance *_clone = (SceneEntityInstance*) clone;
+		_clone->fileName = fileName;
+	}
+}
+
+void SceneEntityInstance::applyScenePrimitive(ObjectEntry *entry, ScenePrimitive *primitive) {
+	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);
+	
+	*/
+}
+
+void SceneEntityInstance::parseObjectIntoCurve(ObjectEntry *entry, BezierCurve *curve) {
+	curve->clearControlPoints();
+	ObjectEntry *controlPoints =(*entry)["controlPoints"];
+	if(controlPoints) {
+		for(int i=0; i < controlPoints->length; i++) {		
+			ObjectEntry *controlPoint = ((*controlPoints))[i];		
+			if(controlPoint) {
+				Vector2 vpt1;
+				Vector2 vpt2;
+				Vector2 vpt3;
+												
+				ObjectEntry *pt1 = ((*controlPoint))["pt1"];
+				if(pt1) {
+					vpt1.x = ((*pt1))["x"]->NumberVal;
+					vpt1.y = ((*pt1))["y"]->NumberVal;					
+				}
+
+				ObjectEntry *pt2 = ((*controlPoint))["pt2"];
+				if(pt2) {
+					vpt2.x = ((*pt2))["x"]->NumberVal;
+					vpt2.y = ((*pt2))["y"]->NumberVal;					
+				}
+
+				ObjectEntry *pt3 = ((*controlPoint))["pt3"];
+				if(pt3) {
+					vpt3.x = ((*pt3))["x"]->NumberVal;
+					vpt3.y = ((*pt3))["y"]->NumberVal;					
+				}
+
+				curve->addControlPoint(vpt1.x, vpt1.y, 0.0, vpt2.x, vpt2.y, 0.0, vpt3.x, vpt3.y, 0.0);
+			}
+		}
+	}
+	
+}
+
+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);										
+			
+			entity = placingEmitter;
+		
+		}		
+
+		if(entityType->stringVal == "ScreenSprite") {
+			ObjectEntry *screenSpriteEntry = (*entry)["ScreenSprite"];			
+			String filePath = (*screenSpriteEntry)["filePath"]->stringVal;
+			
+			ScreenSprite *sprite = new ScreenSprite(filePath);
+			
+			String animName = (*screenSpriteEntry)["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;
+		}
+		
+		if(entityType->stringVal == "ScreenSound") {
+			ObjectEntry *screenSoundEntry = (*entry)["ScreenSound"];
+			
+			String filePath = (*screenSoundEntry)["filePath"]->stringVal;
+			Number refDistance = (*screenSoundEntry)["refDistance"]->NumberVal;
+			Number maxDistance = (*screenSoundEntry)["maxDistance"]->NumberVal;
+			Number volume = (*screenSoundEntry)["volume"]->NumberVal;
+			Number pitch = (*screenSoundEntry)["pitch"]->NumberVal;
+															
+			ScreenSound *sound = new ScreenSound(filePath, refDistance, maxDistance);
+			sound->getSound()->setVolume(volume);
+			sound->getSound()->setPitch(pitch);	
+			
+			sound->setWidth(50);
+			sound->setHeight(50);				
+										
+			entity = sound;
+		}		
+		
+
+		if(entityType->stringVal == "ScreenLabel") {
+			ObjectEntry *screenLabelEntry = (*entry)["ScreenLabel"];
+			
+			String text = (*screenLabelEntry)["text"]->stringVal;
+			String font = (*screenLabelEntry)["font"]->stringVal;
+			int size = (*screenLabelEntry)["size"]->intVal;
+			int aaMode = (*screenLabelEntry)["aaMode"]->intVal;
+												
+			ScreenLabel *label = new ScreenLabel(text, size, font, aaMode);
+			label->positionAtBaseline = false;
+			
+			ObjectEntry *screenShapeEntry = (*entry)["ScreenShape"];			
+			applyScreenShape(screenShapeEntry, label);
+			entity = label;
+		}
+	
+	} 
+
+	if(!entity) {
+		if(targetEntity) {
+			entity = targetEntity;
+		} else {
+			entity = new ScreenEntity();
+		}
+	}
+	
+	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);	
+	}
+
+	entity->color.r = (*entry)["colorR"]->NumberVal;
+	entity->color.g = (*entry)["colorG"]->NumberVal;
+	entity->color.b = (*entry)["colorB"]->NumberVal;
+	entity->color.a = (*entry)["colorA"]->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 {
+	
+	}
+	
+	if((*entry)["id"]->stringVal != "") {
+		entity->id = (*entry)["id"]->stringVal;
+	}
+	
+	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);
+			entity->addChild(childEntity);				
+		}
+	}
+	*/	
+	return entity;
+}
+
+String SceneEntityInstance::getFileName() const {
+	return fileName;
+}
+
+void SceneEntityInstance::clearInstance() {
+	for(int i=0; i < children.size(); i++) {
+		removeChild(children[i]);
+		children[i]->setOwnsChildrenRecursive(true);
+		delete children[i];
+	}
+}
+
+bool SceneEntityInstance::loadFromFile(const String& fileName) {
+
+	clearInstance();
+	
+	resourceEntry->resourceFileTime = OSBasics::getFileTime(fileName);
+
+	this->ownsChildren = true;
+	this->fileName = fileName;
+	Object loadObject;
+	if(!loadObject.loadFromBinary(fileName)) {
+		Logger::log("Error loading entity instance.\n");
+	}	
+	ObjectEntry *root = loadObject.root["root"];
+	
+	if(root) {
+		loadObjectEntryIntoEntity(root, this);
+	}
+	
+	return true;
+}

Core/Contents/Source/PolySceneLine.cpp

@@ -26,43 +26,29 @@
 
 using namespace Polycode;
 
-SceneLine::SceneLine(Vector3 start, Vector3 end) : Entity() {
+SceneLine::SceneLine(Vector3 start, Vector3 end) : SceneMesh(Mesh::LINE_MESH) {
 	this->ent1 = NULL;
-	this->ent2 = NULL;	
-	
+	this->ent2 = NULL;
 	this->start = start;
 	this->end = end;	
-	
-	mesh = new Mesh(Mesh::LINE_MESH);	
-	
-	Polygon *poly = new Polygon();
-	poly->addVertex(0,0,0);
-	poly->addVertex(0,0,0);	
-	mesh->addPolygon(poly);
-	
+	initLine();
 	ignoreParentMatrix = true;
-	
-	lineWidth = 1.0;
-	lineSmooth = false;
-	
 }
 
-SceneLine::SceneLine(Entity *ent1, Entity *ent2) : Entity() {
+SceneLine::SceneLine(Entity *ent1, Entity *ent2) : SceneMesh(Mesh::LINE_MESH) {
 	this->ent1 = ent1;
 	this->ent2 = ent2;	
+	initLine();
+	ignoreParentMatrix = true;
 
-	mesh = new Mesh(Mesh::LINE_MESH);	
-	
+}
+
+void SceneLine::initLine() { 
 	Polygon *poly = new Polygon();
-	poly->addVertex(0,0,0);
-	poly->addVertex(0,0,0);	
+	poly->addVertex(0,0,0,0,0);
+	poly->addVertex(0,0,0,1,0);	
 	mesh->addPolygon(poly);
-	
-	ignoreParentMatrix = true;
-	
-	lineWidth = 1.0;
-	lineSmooth = false;
-	
+	mesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;		
 }
 
 SceneLine *SceneLine::SceneLineWithPositions(Vector3 start, Vector3 end) {
@@ -70,7 +56,6 @@ SceneLine *SceneLine::SceneLineWithPositions(Vector3 start, Vector3 end) {
 }
 
 SceneLine::~SceneLine() {
-	delete mesh;
 }
 
 void SceneLine::setStart(Vector3 start) {
@@ -81,11 +66,11 @@ void SceneLine::setEnd(Vector3 end) {
 	this->end = end;
 }
 
-void SceneLine::Render() {	
+void SceneLine::Update(){
 
 	Vector3 v1;
-	Vector3 v2;		
-
+	Vector3 v2;
+	
 	if(ent1 != NULL && ent2 != NULL) {
 		v1 = ent1->getConcatenatedMatrix().getPosition();
 		v2 = ent2->getConcatenatedMatrix().getPosition();
@@ -93,22 +78,8 @@ void SceneLine::Render() {
 		v1 = start;
 		v2 = end;
 	}
-
 	
-	mesh->getPolygon(0)->getVertex(0)->set(v1.x,v1.y,v1.z); 
-	mesh->getPolygon(0)->getVertex(1)->set(v2.x,v2.y,v2.z); 	
-	mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
-	
-	Renderer *renderer = CoreServices::getInstance()->getRenderer();
-	
-	renderer->setLineSize(lineWidth);
-	renderer->setLineSmooth(lineSmooth);
-	
-	renderer->setTexture(NULL);	
-	renderer->pushDataArrayForMesh(mesh, RenderDataArray::VERTEX_DATA_ARRAY);
-	renderer->pushDataArrayForMesh(mesh, RenderDataArray::TEXCOORD_DATA_ARRAY);	
-	renderer->pushDataArrayForMesh(mesh, RenderDataArray::NORMAL_DATA_ARRAY);		
-	
-	renderer->drawArrays(mesh->getMeshType());	
-	
-}
+	mesh->getPolygon(0)->getVertex(0)->set(v1.x,v1.y,v1.z);
+	mesh->getPolygon(0)->getVertex(1)->set(v2.x,v2.y,v2.z);
+	mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;	
+}

Core/Contents/Source/PolySceneMesh.cpp

@@ -183,6 +183,10 @@ void SceneMesh::setSkeleton(Skeleton *skeleton) {
 	}	
 }
 
+void SceneMesh::setLineWidth(Number newWidth) {
+	lineWidth = newWidth;
+}
+
 Material *SceneMesh::getMaterial() {
 	return material;
 }

Core/Contents/Source/PolySceneSprite.cpp

@@ -0,0 +1,388 @@
+/*
+ Copyright (C) 2013 by Ivan Safrin
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#include "PolySceneSprite.h"
+#include "PolyCore.h"
+#include "PolyCoreServices.h"
+#include "PolyMesh.h"
+#include "PolyPolygon.h"
+#include "PolyTexture.h"
+
+using std::vector;
+using namespace Polycode;
+
+SceneSpriteResourceEntry::SceneSpriteResourceEntry(SceneSprite *sprite)  : Resource(Resource::RESOURCE_SCREEN_ENTITY_INSTANCE) {
+	this->sprite = sprite;
+}
+
+SceneSpriteResourceEntry::~SceneSpriteResourceEntry() {
+
+}
+
+SceneSprite *SceneSpriteResourceEntry::getSprite() {
+	return sprite;
+}
+
+void SceneSpriteResourceEntry::reloadResource() {
+	sprite->reloadSprite();
+	Resource::reloadResource();
+}
+
+SceneSprite* SceneSprite::SceneSpriteFromImageFile(const String& fileName, Number spriteWidth, Number spriteHeight) {
+	return new SceneSprite(fileName, spriteWidth, spriteHeight);
+}
+
+SceneSprite::SceneSprite(const String& fileName) : ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 1, 1) {
+
+	currentFrame = 0;
+	currentAnimation = NULL;	
+	paused = false;
+
+	resourceEntry = new SceneSpriteResourceEntry(this);		
+	loadFromFile(fileName);
+	resourceEntry->setResourceName(fileName);
+	resourceEntry->setResourcePath(fileName);	
+}
+
+Entity *SceneSprite::Clone(bool deepClone, bool ignoreEditorOnly) const {
+	SceneSprite *newSprite = new SceneSprite(getTexture()->getResourcePath(), spriteWidth, spriteHeight);
+	for(int i=0; i < animations.size(); i++) {
+		newSprite->addAnimation(animations[i]->name, animations[i]->frames, animations[i]->speed);
+	}
+	if(currentAnimation) {
+		newSprite->playAnimation(currentAnimation->name, currentFrame, playingOnce);
+	}
+	applyClone(newSprite, deepClone, ignoreEditorOnly);
+	return newSprite;
+}
+
+void SceneSprite::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const {
+//	ScreenShape::applyClone(clone, deepClone, ignoreEditorOnly);	
+}
+
+bool SceneSprite::loadFromFile(const String& fileName) {
+	Object loadObject;
+	
+	animations.clear();
+	
+	if(!loadObject.loadFromXML(fileName)) {
+		return false;
+	}
+	
+	this->fileName = fileName;
+	
+	ObjectEntry *image = loadObject.root["image"];
+	if(image) {
+		ObjectEntry *frameWidth = (*image)["frameWidth"];
+		ObjectEntry *frameHeight = (*image)["frameHeight"];	
+		ObjectEntry *fileName = (*image)["fileName"];
+		
+		if(fileName) {
+			loadTexture(fileName->stringVal);
+		}
+
+		if(frameWidth && frameHeight) {
+			
+			setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, frameWidth->NumberVal, frameHeight->NumberVal);
+			setSpriteSize(frameWidth->NumberVal, frameHeight->NumberVal);
+		}
+	}
+	
+	ObjectEntry *animationsEntry = loadObject.root["animations"];
+	
+	if(animationsEntry) {
+		for(int i=0; i < animationsEntry->length; i++) {
+			ObjectEntry *animation = (*animationsEntry)[i];
+			if(animation) {
+				ObjectEntry *name = (*animation)["name"];
+				ObjectEntry *frames = (*animation)["frames"];	
+				ObjectEntry *speed = (*animation)["speed"];
+				
+				if(name && frames && speed) {
+					addAnimation(name->stringVal, frames->stringVal, speed->NumberVal);
+				} else {
+					printf("Error parsing animation node\n");
+				}
+			}
+		}
+	}
+	
+	recalculateSpriteDimensions();
+
+	return true;
+}
+
+unsigned int SceneSprite::getNumAnimations() {
+	return animations.size();
+}
+
+SpriteAnimation *SceneSprite::getAnimationAtIndex(unsigned int index) {
+	if(index < animations.size()) {
+		return animations[index];
+	} else {
+		return NULL;
+	}
+}
+
+void SceneSprite::reloadSprite() {
+	
+	String _animName = "";
+	int _currentFrame;
+	bool _playingOnce;
+	
+	if(currentAnimation) {
+		_animName = currentAnimation->name;
+		_currentFrame = currentFrame;
+		_playingOnce = playingOnce;
+	}
+	loadFromFile(fileName);
+	
+	if(_animName != "") {
+		playAnimation(_animName, _currentFrame, _playingOnce);
+	}
+}
+
+SceneSpriteResourceEntry *SceneSprite::getResourceEntry() {
+	return resourceEntry;
+}
+
+SceneSprite::SceneSprite(const String& fileName, Number spriteWidth, Number spriteHeight) : ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 1, 1) {
+	this->spriteWidth = spriteWidth;
+	this->spriteHeight = spriteHeight;	
+	loadTexture(fileName);
+		
+	recalculateSpriteDimensions();
+	currentFrame = 0;
+	currentAnimation = NULL;	
+	paused = false;
+}
+
+SceneSprite::~SceneSprite() {
+	
+}
+
+void SceneSprite::recalculateSpriteDimensions() {
+	if(!texture)
+		return;
+		
+	spriteUVWidth = 1.0f / ((Number) texture->getWidth() / spriteWidth);
+	spriteUVHeight = 1.0f / ((Number) texture->getHeight() / spriteHeight);
+	
+	for(int i =0 ; i < animations.size(); i++) {
+		animations[i]->numFramesX = texture->getWidth() / spriteWidth;	
+		if(animations[i]->numFramesX < 1) {
+			animations[i]->numFramesX = 1;
+		}
+		animations[i]->numFramesY = texture->getHeight() / spriteHeight;
+		if(animations[i]->numFramesY < 1) {
+			animations[i]->numFramesY = 1;
+		}		
+		animations[i]->spriteUVWidth = spriteUVWidth;
+		animations[i]->spriteUVHeight = spriteUVHeight;	
+		animations[i]->setOffsetsFromFrameString(animations[i]->frames);
+	}
+}
+
+Vector2 SceneSprite::getSpriteSize() {
+	return Vector2(spriteWidth, spriteHeight);
+}
+
+String SceneSprite::getFileName() const {
+	return fileName;
+}
+
+void SceneSprite::setSpriteSize(const Number spriteWidth, const Number spriteHeight) {
+	this->spriteWidth = spriteWidth;
+	this->spriteHeight = spriteHeight;	
+	
+	recalculateSpriteDimensions();	
+}
+
+SpriteAnimation *SceneSprite::getCurrentAnimation() {
+	return currentAnimation;
+}
+
+unsigned int SceneSprite::getCurrentAnimationFrame() { 
+   return currentFrame; 
+}
+
+bool SceneSprite::isCurrentAnimationFinished() {
+    if(currentAnimation) {
+        if(currentFrame >= currentAnimation->numFrames)
+            return true;
+    }
+    return false;
+}
+
+void SpriteAnimation::setOffsetsFromFrameString(const String& frames) {
+	framesOffsets.clear();
+	vector<String> frameNumbers = frames.split(",");
+	
+	int frameNumber;
+	int frameX;
+	int frameY;
+	
+	numFrames = 0;
+	
+	for(int i=0; i < frameNumbers.size(); i++) {
+		if(frameNumbers[i].find_first_of("-") != -1) {
+			vector<String> _frameNumbers = frameNumbers[i].split("-");
+			if(_frameNumbers.size() > 1) {
+				int frameNumberStart = atoi(_frameNumbers[0].c_str());
+				int frameNumberEnd = atoi(_frameNumbers[1].c_str());
+				int dir = 1;
+				if(frameNumberEnd < frameNumberStart) {
+					dir = -1;
+				}				
+				for(int j=frameNumberStart; j != frameNumberEnd + dir; j += dir) {
+					frameX = j % numFramesX;
+					frameY = j/numFramesX;
+					framesOffsets.push_back(Vector2(spriteUVWidth * frameX, spriteUVHeight * frameY));
+					numFrames++;
+				}
+			}
+		} else if(frameNumbers[i].find_first_of("x") != -1) {
+			vector<String> _frameNumbers = frameNumbers[i].split("x");
+			if(_frameNumbers.size() > 1) {
+				int _frameNumber = atoi(_frameNumbers[0].c_str());
+				int frameNumberCount = atoi(_frameNumbers[1].c_str());				
+				for(int j=0; j < frameNumberCount; j++) {
+					frameX = _frameNumber % numFramesX;
+					frameY = _frameNumber/numFramesX;
+					framesOffsets.push_back(Vector2(spriteUVWidth * frameX, spriteUVHeight * frameY));
+					numFrames++;					
+				}
+			}				
+		} else {	
+			frameNumber = atoi(frameNumbers[i].c_str());
+			frameX = frameNumber % numFramesX;
+			frameY = frameNumber/numFramesX;
+			framesOffsets.push_back(Vector2(spriteUVWidth * frameX, spriteUVHeight * frameY));
+			numFrames++;			
+		}
+	}
+	
+	this->frames = frames;
+
+}
+
+SpriteAnimation *SceneSprite::addAnimation(const String& name, const String& frames, Number speed) {
+	SpriteAnimation *newAnimation = new SpriteAnimation();	
+	
+	
+	newAnimation->numFramesX = texture->getWidth() / spriteWidth;	
+	if(newAnimation->numFramesX < 1) {
+		newAnimation->numFramesX = 1;
+	}
+	newAnimation->numFramesY = texture->getHeight() / spriteHeight;
+	if(newAnimation->numFramesY < 1) {
+		newAnimation->numFramesY = 1;
+	}	
+	newAnimation->spriteUVWidth = spriteUVWidth;
+	newAnimation->spriteUVHeight = spriteUVHeight;
+	
+	newAnimation->setOffsetsFromFrameString(frames);
+			
+	newAnimation->speed = speed;
+	newAnimation->name = name;
+	animations.push_back(newAnimation);
+	return newAnimation;
+}
+
+void SceneSprite::playAnimation(const String& name, int startFrame, bool once) {
+	paused = false;
+	for(int i=0; i < animations.size(); i++) {
+		if(animations[i]->name == name) {
+			if(currentAnimation == animations[i] && !playingOnce && !once)
+				return;
+			currentFrame = 0;			
+			currentAnimation = animations[i];
+			if(startFrame == -1) {
+				currentFrame = rand() % currentAnimation->numFrames;
+			} else {
+				if(startFrame < currentAnimation->numFrames) {
+					currentFrame = startFrame;
+				}
+			}
+			playingOnce = once;
+			lastTick = 0;
+		}
+	}
+}
+
+void SceneSprite::Pause(bool val) {
+	paused = val;
+}
+
+void SceneSprite::showFrame(unsigned int frameIndex) {
+	if(!currentAnimation)
+		return;
+
+	if(frameIndex < currentAnimation->numFrames) {
+		currentFrame = frameIndex;
+		updateSprite();
+	}
+}
+
+void SceneSprite::Update() {
+	if(!currentAnimation)
+		return;
+	
+	Number newTick = CoreServices::getInstance()->getCore()->getTicksFloat();
+	
+	Number elapsed = newTick - lastTick;
+	
+	if(paused)
+		return;
+	
+	if(elapsed > currentAnimation->speed) {
+	currentFrame++;
+	if(currentFrame >= currentAnimation->numFrames) {
+		if(playingOnce) {
+			dispatchEvent(new Event(), Event::COMPLETE_EVENT);
+			return;			
+		} else {
+			currentFrame = 0;
+		}
+	}
+	
+	updateSprite();
+			
+	lastTick = newTick;
+		
+	}
+}
+
+void SceneSprite::updateSprite() {
+	Number xOffset = currentAnimation->framesOffsets[currentFrame].x;
+	Number yOffset = 1.0f - currentAnimation->framesOffsets[currentFrame].y - spriteUVHeight;
+	
+	Polygon *imagePolygon = mesh->getPolygon(0);
+		
+	imagePolygon->getVertex(0)->setTexCoord(xOffset, yOffset+spriteUVHeight);	
+	imagePolygon->getVertex(1)->setTexCoord(xOffset+spriteUVWidth, yOffset+spriteUVHeight);
+	imagePolygon->getVertex(2)->setTexCoord(xOffset+spriteUVWidth, yOffset);
+	imagePolygon->getVertex(3)->setTexCoord(xOffset, yOffset);	
+		
+	mesh->arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;
+
+}

IDE/Build/Mac OS X/Polycode.xcodeproj/project.pbxproj

@@ -17,7 +17,6 @@
 		6D34143412B816BC0034FA9B /* IOKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 6D34143312B816BC0034FA9B /* IOKit.framework */; };
 		6D3B6C5B14B820A900727F17 /* ToolWindows.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D3B6C5A14B820A900727F17 /* ToolWindows.cpp */; };
 		6D3DC79D1622043A003ED2C9 /* PolycodeConsole.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D3DC79C1622043A003ED2C9 /* PolycodeConsole.cpp */; };
-		6D56156814C5430300FC8BD4 /* PolycodeScreenEditor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D56156714C5430300FC8BD4 /* PolycodeScreenEditor.cpp */; };
 		6D6D3FA614B446A600219173 /* PolycodeToolLauncher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D6D3FA514B446A600219173 /* PolycodeToolLauncher.cpp */; };
 		6D70AB2A12B29BF200EB6D94 /* NewFileWindow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D70AB2912B29BF200EB6D94 /* NewFileWindow.cpp */; };
 		6D79732E167F0D4600646407 /* PolycodeSpriteEditor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D79732D167F0D4600646407 /* PolycodeSpriteEditor.cpp */; };
@@ -92,8 +91,6 @@
 		6D3B6C5C14B820B000727F17 /* ToolWindows.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ToolWindows.h; sourceTree = "<group>"; };
 		6D3DC79C1622043A003ED2C9 /* PolycodeConsole.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PolycodeConsole.cpp; sourceTree = "<group>"; };
 		6D3DC79F16220440003ED2C9 /* PolycodeConsole.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PolycodeConsole.h; sourceTree = "<group>"; };
-		6D56156514C542FB00FC8BD4 /* PolycodeScreenEditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PolycodeScreenEditor.h; sourceTree = "<group>"; };
-		6D56156714C5430300FC8BD4 /* PolycodeScreenEditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PolycodeScreenEditor.cpp; sourceTree = "<group>"; };
 		6D6D3FA514B446A600219173 /* PolycodeToolLauncher.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp.preprocessed; fileEncoding = 4; path = PolycodeToolLauncher.cpp; sourceTree = "<group>"; };
 		6D6D3FA814B446AF00219173 /* PolycodeToolLauncher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PolycodeToolLauncher.h; sourceTree = "<group>"; };
 		6D70AB2812B29BEC00EB6D94 /* NewFileWindow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NewFileWindow.h; sourceTree = "<group>"; };
@@ -284,7 +281,6 @@
 				6DD1835F1628A4D2005A5682 /* PolycodeRemoteDebugger.h */,
 				6D3DC79F16220440003ED2C9 /* PolycodeConsole.h */,
 				6D797330167F0D4D00646407 /* PolycodeSpriteEditor.h */,
-				6D56156514C542FB00FC8BD4 /* PolycodeScreenEditor.h */,
 				6D797331167F0EA500646407 /* PolycodeProps.h */,
 				6D2AC99D14B8500A00BB63DA /* PolycodeProjectEditor.h */,
 				6D3B6C5C14B820B000727F17 /* ToolWindows.h */,
@@ -320,7 +316,6 @@
 				6D80B0CD163B14CB00EF3C04 /* PolycodeMaterialEditor.cpp */,
 				6DD1835C1628A4CC005A5682 /* PolycodeRemoteDebugger.cpp */,
 				6D3DC79C1622043A003ED2C9 /* PolycodeConsole.cpp */,
-				6D56156714C5430300FC8BD4 /* PolycodeScreenEditor.cpp */,
 				6D797332167F0EB100646407 /* PolycodeProps.cpp */,
 				6D2AC99A14B8500400BB63DA /* PolycodeProjectEditor.cpp */,
 				6D3B6C5A14B820A900727F17 /* ToolWindows.cpp */,
@@ -446,7 +441,6 @@
 				6DCAFD4314B519C900039F34 /* ExampleBrowserWindow.cpp in Sources */,
 				6D3B6C5B14B820A900727F17 /* ToolWindows.cpp in Sources */,
 				6D2AC99B14B8500400BB63DA /* PolycodeProjectEditor.cpp in Sources */,
-				6D56156814C5430300FC8BD4 /* PolycodeScreenEditor.cpp in Sources */,
 				6D3DC79D1622043A003ED2C9 /* PolycodeConsole.cpp in Sources */,
 				6DD1835D1628A4CC005A5682 /* PolycodeRemoteDebugger.cpp in Sources */,
 				6D80B0CE163B14CB00EF3C04 /* PolycodeMaterialEditor.cpp in Sources */,

IDE/Contents/Include/PolycodeFrame.h

@@ -97,7 +97,7 @@ class EditCurve : public UIElement {
 		void handleEvent(Event *event);
 		
 		BezierCurve *targetCurve;
-		ScreenMesh *visMesh;
+		SceneMesh *visMesh;
 		Polycode::Polygon *poly;	
 		
 		EditPoint *pointToRemove;
@@ -151,7 +151,7 @@ class EditorHolder : public UIElement {
 		
 };
 
-class PolycodeFrame : public Entity {
+class PolycodeFrame : public UIElement {
 public:
 	
 	PolycodeFrame();

IDE/Contents/Include/PolycodeIDEApp.h

@@ -36,7 +36,6 @@
 
 #include "PolycodeImageEditor.h"
 #include "PolycodeMaterialEditor.h"
-#include "PolycodeScreenEditor.h"
 #include "PolycodeFontEditor.h"
 #include "PolycodeTextEditor.h"
 #include "PolycodeProjectEditor.h"

IDE/Contents/Include/PolycodeProps.h

@@ -320,10 +320,10 @@ class TextureProp : public PropProp {
 		String currentData;
 };
 
-class ScreenSpriteProp : public PropProp {
+class SceneSpriteProp : public PropProp {
 	public:
-		ScreenSpriteProp(String caption);
-		~ScreenSpriteProp();
+		SceneSpriteProp(String caption);
+		~SceneSpriteProp();
 		void handleEvent(Event *event);
 		
 		void setPropData(PolycodeEditorPropActionData* data);
@@ -331,7 +331,7 @@ class ScreenSpriteProp : public PropProp {
 		void set(String fileName);
 		String get();		
 				
-		ScreenSprite *previewSprite;
+		SceneSprite *previewSprite;
 		UIButton *changeButton;
 		
 		String lastData;
@@ -339,10 +339,10 @@ class ScreenSpriteProp : public PropProp {
 };
 
 
-class EntityInstanceProp : public PropProp {
+class SceneEntityInstanceProp : public PropProp {
 	public:
-		EntityInstanceProp(String caption);
-		~EntityInstanceProp();
+		SceneEntityInstanceProp(String caption);
+		~SceneEntityInstanceProp();
 		void handleEvent(Event *event);			
 		
 		void setPropData(PolycodeEditorPropActionData* data);
@@ -350,7 +350,7 @@ class EntityInstanceProp : public PropProp {
 		void set(String fileName);
 		String get();		
 				
-		EntityInstance *previewInstance;
+		SceneEntityInstance *previewInstance;
 		UIButton *changeButton;
 		
 		String lastData;
@@ -527,29 +527,6 @@ class EntityPropSheet : public PropSheet {
 		
 };
 
-class ShapeSheet : public PropSheet {
-	public:
-		ShapeSheet();
-		~ShapeSheet();
-		
-		void handleEvent(Event *event);
-		void Update();
-				
-		ScenePrimitive *shape;
-	
-		ComboProp *typeProp;
-		Vector2Prop *shapeSize;
-		BoolProp *strokeProp;
-		ColorProp *strokeColorProp;
-		NumberProp *strokeSize;
-						
-		bool lastStrokeVal;
-		int lastShapeType;
-		Vector2 lastShapeSize;
-		Color lastStrokeColor;
-		Number lastStrokeSize;
-};
-
 class SceneLabelSheet : public PropSheet {
 	public:
 		SceneLabelSheet();
@@ -572,62 +549,32 @@ class SceneLabelSheet : public PropSheet {
 		BoolProp *enableAA;
 };
 
-
-class UIImageSheet : public PropSheet {
+class SceneSpriteSheet : public PropSheet {
 	public:
-		UIImageSheet();
-		~UIImageSheet();
+		SceneSpriteSheet();
+		~SceneSpriteSheet();
 		
 		void handleEvent(Event *event);
 		void Update();
 				
-		UIImage *image;
-		
-		TextureProp *texture;
-		
-};
-
-class ScreenSpriteSheet : public PropSheet {
-	public:
-		ScreenSpriteSheet();
-		~ScreenSpriteSheet();
-		
-		void handleEvent(Event *event);
-		void Update();
-				
-		ScreenSprite *sprite;	
-		ScreenSpriteProp *spriteProp;
+		SceneSprite *sprite;	
+		SceneSpriteProp *spriteProp;
 		ComboProp *defaultAnimationProp;		
-		ScreenSprite *lastSprite;
+		SceneSprite *lastSprite;
 		
 };
 
 
-class EntityInstanceSheet : public PropSheet {
+class SceneEntityInstanceSheet : public PropSheet {
 	public:
-		EntityInstanceSheet();
-		~EntityInstanceSheet();
+		SceneEntityInstanceSheet();
+		~SceneEntityInstanceSheet();
 		
 		void handleEvent(Event *event);
 		void Update();
 				
-		EntityInstance *instance;
-		EntityInstanceProp *instanceProp;
-};
-
-class EntitySheet : public PropSheet {
-	public:
-		EntitySheet();
-		~EntitySheet();
-		
-		void handleEvent(Event *event);
-		void Update();
-		
-		NumberProp *widthProp;
-		NumberProp *heightProp;
-		
-		Entity *entity;
-		Entity *lastEntity;
+		SceneEntityInstance *instance;
+		SceneEntityInstanceProp *instanceProp;
 };
 
 class SoundSheet : public PropSheet {
@@ -638,7 +585,7 @@ class SoundSheet : public PropSheet {
 		void handleEvent(Event *event);
 		void Update();
 				
-		ScreenSound *sound;
+		SceneSound *sound;
 
 		SoundProp *soundProp;		
 		NumberProp *referenceDistance;
@@ -653,80 +600,6 @@ class SoundSheet : public PropSheet {
 		Number lastPitch;
 };
 
-class ScreenParticleSheet : public PropSheet {
-	public:
-		ScreenParticleSheet();
-		~ScreenParticleSheet();		
-		
-		void handleEvent(Event *event);
-		
-		void Update();
-
-		TextureProp *textureProp;
-		ComboProp *blendingProp;
-		BoolProp *ignoreParentMatrixProp;
-		NumberProp *numParticlesProp;
-		NumberProp *lifespanProp;
-		NumberProp *particleScaleProp;		
-		Vector2Prop *sizeProp;
-		Vector2Prop *dirProp;
-		Vector2Prop *gravProp;		
-		Vector2Prop *deviationProp;	
-		SliderProp *brightnessDeviationProp;
-		BoolProp *perlinEnableProp;
-		NumberProp *perlinModSizeProp;
-		SliderProp *speedModProp;
-		NumberProp *rotationSpeedProp;
-		BoolProp *rotationFollowsPathProp;		
-		BoolProp *useScaleCurvesProp;		
-		BezierCurveProp *scaleCurveProp;
-		
-		BoolProp *useColorCurvesProp;		
-		BezierRGBACurveProp *colorCurveProp;
-				
-		Number lastParticleScale;		
-		Number lastRotationSpeed;
-		Number lastNumParticles;
-		Number lastLifespan;
-		Vector3 lastSize;
-		Vector3 lastDeviation;
-		Vector3 lastDir;
-		Vector3 lastGrav;				
-		Number lastBrightnessDeviation;
-		bool lastEnableProp;
-		Number lastPerlinSize;
-		Number lastSpeedMod;
-		bool lastIgnoreParentMatrix;
-		bool lastRotationFollowsPath;
-		bool lastUseScaleCurves;
-		bool lastUseColorCurves;		
-		BezierCurve *lastScaleCurve;
-		
-		ScreenParticleEmitter *emitter;
-};
-
-class Transform2DSheet : public PropSheet {
-	public:
-		Transform2DSheet();
-		~Transform2DSheet();		
-		
-		void handleEvent(Event *event);
-		
-		void Update();
-		
-		Vector2Prop *positionProp;
-		Vector2Prop *scaleProp;	
-		NumberProp *rotationProp;
-		BoolProp *topLeftProp;
-				
-		Vector2 lastPositon;
-		Vector2 lastScale;
-		Number lastRotation;
-		int lastPositionMode;
-		
-		Entity *entity;
-};
-
 class PropList : public UIElement {
 	public:
 		PropList(String caption="PROPERTIES");

IDE/Contents/Include/PolycodeScreenEditor.h

@@ -160,8 +160,8 @@ class PolycodeScreenEditorMain : public UIElement {
 			
 		void processEventForEntity(Entity *childEntity, InputEvent *inputEvent);
 	
-		void createParticleRef(ScreenParticleEmitter *target);
-		void createSoundRef(ScreenSound *target);
+		void createParticleRef(SceneParticleEmitter *target);
+		void createSoundRef(SceneSound *target);
 		void createEntityRef(Entity *entity);
 		
 		void doAction(String actionName, PolycodeEditorActionData *data);
@@ -210,15 +210,13 @@ class PolycodeScreenEditorMain : public UIElement {
 		
 		Transform2DSheet *transform2dSheet;
 		EntitySheet *entitySheet;
-		ShapeSheet *shapeSheet;
 		UIImageSheet *imageSheet;
 		SceneLabelSheet *labelSheet;
 		SoundSheet *soundSheet;
 		EntityPropSheet *entityPropSheet;
-		EntityInstanceSheet *instanceSheet;
-		ScreenSpriteSheet *spriteSheet;
+		SceneEntityInstanceSheet *instanceSheet;
+		SceneSpriteSheet *spriteSheet;
 		ScreenParticleSheet *particleSheet;
-		EntitySheet *EntitySheet;
 		
 		EntityTreeView *treeView;
 		
@@ -240,15 +238,15 @@ class PolycodeScreenEditorMain : public UIElement {
 	
 		ScenePrimitive *previewShape;
 		UIImage *previewImage;
-		EntityInstance *previewInstance;		
+		SceneEntityInstance *previewInstance;		
 		SceneLabel *previewLabel;							
 		Entity *previewEntity;
-		ScreenParticleEmitter *previewEmitter;
+		SceneParticleEmitter *previewEmitter;
 							
-		ScreenSound *previewSound;
-		ScreenSprite *previewSprite;
+		SceneSound *previewSound;
+		SceneSprite *previewSprite;
 											
-		ScreenMesh *grid;
+		SceneMesh *grid;
 
 		bool firstResize;
 		

IDE/Contents/Include/PolycodeSpriteEditor.h

@@ -79,7 +79,7 @@ class PolycodeSpriteEditor : public PolycodeEditor {
 	
 	bool initialLoad;
 	
-	ScreenSprite *previewSprite;
+	SceneSprite *previewSprite;
 };
 
 class PolycodeSpriteEditorFactory : public PolycodeEditorFactory {

IDE/Contents/Source/PolycodeConsole.cpp

@@ -343,6 +343,6 @@ void PolycodeConsole::_print(String msg) {
 }
 
 void PolycodeConsole::Resize(Number width, Number height) {
-	backtraceSizer->Resize(width, height);
+	backtraceSizer->Resize(getWidth(), getHeight());
 	backtraceSizer->setPosition(0, 0);
 }

IDE/Contents/Source/PolycodeFrame.cpp

@@ -219,7 +219,7 @@ EditCurve::EditCurve(BezierCurve *targetCurve, Color curveColor) : UIElement() {
 		poly->addVertex(0.0, 0.0, 0.0);
 	}
 	
-	visMesh = new ScreenMesh(Mesh::LINE_STRIP_MESH);
+	visMesh = new SceneMesh(Mesh::LINE_STRIP_MESH);
 	visMesh->getMesh()->addPolygon(poly);
 	
 	visMesh->lineSmooth = true;
@@ -489,12 +489,12 @@ EditorHolder::~EditorHolder() {
 		
 void EditorHolder::Resize(Number width, Number height) {
 	if(currentEditor) {
-		currentEditor->Resize(width, height);
+		currentEditor->Resize(getWidth(), getHeight());
 	}
 }
 
 
-PolycodeFrame::PolycodeFrame() : Entity() {
+PolycodeFrame::PolycodeFrame() : UIElement() {
 
 	globalFrame = this;
 	processInputEvents = true;
@@ -849,7 +849,7 @@ void PolycodeFrame::handleEvent(Event *event) {
 			break;
 			case InputEvent::EVENT_MOUSEMOVE:			
 				if(isDragging) {
-					dragEntity->setPosition(((InputEvent*)event)->mousePosition);
+					//dragEntity->setPosition(((InputEvent*)event)->mousePosition);
 				}
 			break;
 			// TODO: add in key combos to switch editors in reverse order

IDE/Contents/Source/PolycodeIDEApp.cpp

@@ -76,8 +76,9 @@ PolycodeIDEApp::PolycodeIDEApp(PolycodeView *view) : EventDispatcher() {
 			
 	printf("creating font editor\n"); 
 	
-	Screen *screen = new Screen();	
-	screen->rootEntity.setDefaultScreenOptions(true);
+	Scene *screen = new Scene(Scene::SCENE_2D_TOPLEFT);	
+	screen->rootEntity.processInputEvents = true;
+//	screen->rootEntity.setDefaultScreenOptions(true);
 	
 	editorManager = new PolycodeEditorManager();
 	
@@ -129,7 +130,6 @@ PolycodeIDEApp::PolycodeIDEApp(PolycodeView *view) : EventDispatcher() {
 	
 	editorManager->registerEditorFactory(new PolycodeImageEditorFactory());
 	editorManager->registerEditorFactory(new PolycodeMaterialEditorFactory());	
-	editorManager->registerEditorFactory(new PolycodeScreenEditorFactory());	
 	editorManager->registerEditorFactory(new PolycodeFontEditorFactory());
 	editorManager->registerEditorFactory(new PolycodeTextEditorFactory());
 	editorManager->registerEditorFactory(new PolycodeProjectEditorFactory(projectManager));

IDE/Contents/Source/PolycodeMaterialEditor.cpp

@@ -99,7 +99,7 @@ PostEditorPane::~PostEditorPane() {
 }
 
 void PostEditorPane::Resize(Number width, Number height) {
-	mainSizer->Resize(width, height);
+	mainSizer->Resize(getWidth(), getHeight());
 	headerBgBottom->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, width, 30);	
 	propList->Resize(width/2.0, height- mainSizer->getMainHeight());
 	
@@ -107,7 +107,7 @@ void PostEditorPane::Resize(Number width, Number height) {
 	optionsPropList->Resize(width/2.0, height- mainSizer->getMainHeight());
 	optionsPropList->setPosition(floor(width/2.0), optionsPropList->getPosition().y);
 	optionsPropList->updateProps();	
-	UIElement::Resize(width, height);
+	UIElement::Resize(getWidth(), getHeight());
 	adjustPreview();
 }
 
@@ -640,7 +640,7 @@ void PostPreviewBox::Resize(Number width, Number height) {
 	int textureHeight = (int) (height-30);
 	renderTexture->resizeRenderTexture(textureWidth, textureHeight);
 	previewShape->setTexture(renderTexture->getTargetTexture());	
-	UIElement::Resize(width, height);
+	UIElement::Resize(getWidth(), getHeight());
 	
 	if(currentMaterial) {
 		for(int i=0; i < currentMaterial->getNumShaderRenderTargets(); i++) {
@@ -741,9 +741,6 @@ MaterialPreviewBox::MaterialPreviewBox() : UIElement() {
 	previewShape->setAnchorPoint(-1.0, -1.0, 0.0);	
 	previewShape->setTexture(renderTexture->getTargetTexture());
 	previewShape->setPosition(20,40);
-	previewShape->strokeEnabled = true;
-	previewShape->strokeColor = Color(1.0, 1.0, 1.0, 0.2);
-	previewShape->setStrokeWidth(1.0);
 	previewBase->addChild(previewShape);
 	
 	shapeSelector = new UIImage("Images/small_selector.png");
@@ -987,10 +984,10 @@ MaterialMainWindow::MaterialMainWindow() : UIElement() {
 void MaterialMainWindow::Resize(Number width, Number height) {	
 	Vector2 pos = getScreenPosition();	
 	scissorBox.setRect(pos.x,pos.y,width, height);
-	materialPane->Resize(width, height);
-	shaderPane->Resize(width, height);
-	cubemapPane->Resize(width, height);
-	postPane->Resize(width, height);
+	materialPane->Resize(getWidth(), getHeight());
+	shaderPane->Resize(getWidth(), getHeight());
+	cubemapPane->Resize(getWidth(), getHeight());
+	postPane->Resize(getWidth(), getHeight());
 }
 
 MaterialBrowser::MaterialBrowser() : UIElement() {

IDE/Contents/Source/PolycodeProps.cpp

@@ -181,7 +181,7 @@ void PropList::Resize(Number width, Number height) {
 			offsetY += props[i]->propHeight;
 		}
 		}
-		props[i]->Resize(width, height);
+		props[i]->Resize(getWidth(), getHeight());
 	}
 	
 	rebuildTransformMatrix();
@@ -191,7 +191,7 @@ void PropList::Resize(Number width, Number height) {
 
 void PropList::handleEvent(Event *event) {
 	if(event->getEventType() == "" && event->getEventCode() == Event::COMPLETE_EVENT) {
-		Resize(width, height);
+		Resize(getWidth(), getHeight());
 	} else if(event->getEventCode() == Event::CHANGE_EVENT) {
 	
 	}
@@ -200,7 +200,7 @@ void PropList::handleEvent(Event *event) {
 void PropList::addPropSheet(PropSheet *sheet) {
 	propContents->addChild(sheet);
 	props.push_back(sheet);
-	Resize(width, height);
+	Resize(getWidth(), getHeight());
 	sheet->addEventListener(this, Event::COMPLETE_EVENT);
 	sheet->addEventListener(this, Event::CHANGE_EVENT);	
 }
@@ -305,7 +305,7 @@ void PropSheet::addProp(PropProp *prop) {
 	props.push_back(prop);
 	prop->addEventListener(this, Event::CHANGE_EVENT);
 	prop->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);	
-	Resize(width, height);
+	Resize(getWidth(), getHeight());
 }
 
 
@@ -980,9 +980,9 @@ Texture* TextureProp::get() {
 	return previewShape->getTexture();
 }
 
-ScreenSpriteProp::ScreenSpriteProp(String caption) : PropProp(caption, "ScreenSprite"){
+SceneSpriteProp::SceneSpriteProp(String caption) : PropProp(caption, "SceneSprite"){
 
-		previewSprite = new ScreenSprite("default/default.sprite");
+		previewSprite = new SceneSprite("default/default.sprite");
 		previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
 		previewSprite->setPosition(2, 1);
 		previewSprite->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, 48,48);		
@@ -996,11 +996,11 @@ ScreenSpriteProp::ScreenSpriteProp(String caption) : PropProp(caption, "ScreenSp
 	setHeight(70);
 }
 
-ScreenSpriteProp::~ScreenSpriteProp() {
+SceneSpriteProp::~SceneSpriteProp() {
 
 }
 
-void ScreenSpriteProp::handleEvent(Event *event) {
+void SceneSpriteProp::handleEvent(Event *event) {
 
 	if(event->getDispatcher() == globalFrame->assetBrowser && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::OK_EVENT) {
 		String filePath = globalFrame->assetBrowser->getSelectedAssetPath();
@@ -1022,12 +1022,12 @@ void ScreenSpriteProp::handleEvent(Event *event) {
 	}
 }
 
-void ScreenSpriteProp::setPropData(PolycodeEditorPropActionData* data) {
+void SceneSpriteProp::setPropData(PolycodeEditorPropActionData* data) {
 	set(data->stringVal);
 	dispatchEvent(new Event(), Event::CHANGE_EVENT);	
 }
 
-void ScreenSpriteProp::set(String fileName) {
+void SceneSpriteProp::set(String fileName) {
 
 	if(fileName != previewSprite->getFileName()) {
 		if(previewSprite) {
@@ -1037,7 +1037,7 @@ void ScreenSpriteProp::set(String fileName) {
 		lastData = currentData;
 		currentData = fileName;
 		
-		previewSprite = new ScreenSprite(fileName);
+		previewSprite = new SceneSprite(fileName);
 		previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
 		previewSprite->setPosition(2, 1);
 		previewSprite->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, 48,48);		
@@ -1045,12 +1045,12 @@ void ScreenSpriteProp::set(String fileName) {
 	}
 }
 
-String ScreenSpriteProp::get() {
+String SceneSpriteProp::get() {
 	return previewSprite->getFileName();
 }
 
-EntityInstanceProp::EntityInstanceProp(String caption) : PropProp(caption, "EntityInstance"){
-	previewInstance = new EntityInstance("default/default.entity2d");
+SceneEntityInstanceProp::SceneEntityInstanceProp(String caption) : PropProp(caption, "SceneEntityInstance"){
+	previewInstance = new SceneEntityInstance("default/default.entity2d");
 	previewInstance->setAnchorPoint(-1.0, -1.0, 0.0);
 	previewInstance->setPosition(2, 1);
 	propContents->addChild(previewInstance);
@@ -1062,12 +1062,12 @@ EntityInstanceProp::EntityInstanceProp(String caption) : PropProp(caption, "Enti
 	setHeight(50);
 }
 
-EntityInstanceProp::~EntityInstanceProp() {
+SceneEntityInstanceProp::~SceneEntityInstanceProp() {
 
 }
 
 
-void EntityInstanceProp::handleEvent(Event *event) {
+void SceneEntityInstanceProp::handleEvent(Event *event) {
 
 	if(event->getDispatcher() == globalFrame->assetBrowser && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::OK_EVENT) {
 		String filePath = globalFrame->assetBrowser->getSelectedAssetPath();
@@ -1089,17 +1089,17 @@ void EntityInstanceProp::handleEvent(Event *event) {
 	}
 }
 
-void EntityInstanceProp::setPropData(PolycodeEditorPropActionData* data) {
+void SceneEntityInstanceProp::setPropData(PolycodeEditorPropActionData* data) {
 	set(data->stringVal);
 	dispatchEvent(new Event(), Event::CHANGE_EVENT);
 }
 
-void EntityInstanceProp::set(String fileName) {
+void SceneEntityInstanceProp::set(String fileName) {
 
 	if(fileName != previewInstance->getFileName()) {
 		propContents->removeChild(previewInstance);
 		delete previewInstance;
-		previewInstance = new EntityInstance(fileName);
+		previewInstance = new SceneEntityInstance(fileName);
 		previewInstance->setAnchorPoint(-1.0, -1.0, 0.0);
 		previewInstance->setPosition(2, 1);
 		
@@ -1115,110 +1115,10 @@ void EntityInstanceProp::set(String fileName) {
 	}
 }
 
-String EntityInstanceProp::get() {
+String SceneEntityInstanceProp::get() {
 	return previewInstance->getFileName();
 }
 
-ShapeSheet::ShapeSheet() : PropSheet("SCREEN SHAPE", "ScenePrimitive") {
-	shapeSize = new Vector2Prop("Shape size");
-	addProp(shapeSize);
-
-	typeProp = new ComboProp("Shape type");
-	addProp(typeProp);
-	
-	typeProp->comboEntry->addComboItem("Rectangle");
-	typeProp->comboEntry->addComboItem("Oval");
-
-	strokeProp = new BoolProp("Enable stroke");
-	addProp(strokeProp);
-
-	strokeColorProp = new ColorProp("Stroke color");
-	addProp(strokeColorProp);
-			
-	strokeSize = new NumberProp("Stroke width");
-	addProp(strokeSize);		
-			
-	propHeight = 190;	
-	
-	shape = NULL;
-	lastShapeType = -10;
-
-}
-
-ShapeSheet::~ShapeSheet() {
-
-}
-		
-void ShapeSheet::handleEvent(Event *event) {
-
-	if(!shape)
-		return;
-
-	if(event->getDispatcher() == strokeProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastStrokeVal = strokeProp->get();
-		shape->strokeEnabled = lastStrokeVal;
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == shapeSize  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastShapeSize = shapeSize->get();
-		shape->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, lastShapeSize.x, lastShapeSize.y);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);	
-	}
-
-	if(event->getDispatcher() == typeProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastShapeType = typeProp->get();
-		shape->setShapeType(lastShapeType+1);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	if(event->getDispatcher() == strokeColorProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastStrokeColor = strokeColorProp->get();
-		shape->strokeColor = lastStrokeColor;
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == strokeSize  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastStrokeSize = strokeSize->get();
-		shape->strokeWidth = lastStrokeSize;
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);	
-	}
-	
-	PropSheet::handleEvent(event);
-}
-
-void ShapeSheet::Update() {
-	if(shape) {
-	
-		enabled = true;
-			
-		if(lastShapeSize.x != shape->getWidth() && lastShapeSize.y != shape->getHeight()) {
-			lastShapeSize = Vector2(shape->getWidth(), shape->getHeight());
-			shapeSize->set(lastShapeSize);
-		}
-		
-		if(lastShapeType != shape->getShapeType()-1) {
-			typeProp->set(shape->getShapeType()-1);			
-			lastShapeType = shape->getShapeType()-1;			
-		}
-		
-		if(lastStrokeVal != shape->strokeEnabled) {
-			strokeProp->set(shape->strokeEnabled);
-			lastStrokeVal = shape->strokeEnabled;
-		}
-		
-		if(lastStrokeColor != shape->strokeColor) {
-			strokeColorProp->set(shape->strokeColor);
-		}
-		
-		if(lastStrokeSize != shape->strokeWidth) {
-			strokeSize->set(shape->strokeWidth);
-		}
-	} else {
-		enabled = false;
-	}
-}
-
 ShaderPassProp::ShaderPassProp(Material *material, int shaderIndex) : PropProp("", "ShaderPassProp") {
 	this->material = material;
 	this->shader = material->getShader(shaderIndex);
@@ -1567,7 +1467,7 @@ void ShaderPassesSheet::refreshPasses() {
 	propHeight += 70;	
 
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);		
-	Resize(width, height);	
+	Resize(getWidth(), getHeight());	
 	
 }
 
@@ -1669,7 +1569,7 @@ void TargetBindingsSheet::refreshTargets() {
 	propHeight += 70;	
 
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);		
-	Resize(width, height);	
+	Resize(getWidth(), getHeight());	
 }
 
 void TargetBindingsSheet::handleEvent(Event *event) {
@@ -1744,7 +1644,7 @@ void RenderTargetsSheet::refreshTargets() {
 	propHeight += 70;	
 
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);		
-	Resize(width, height);	
+	Resize(getWidth(), getHeight());	
 }
 
 void RenderTargetsSheet::Update() {
@@ -1891,7 +1791,7 @@ void EntityPropSheet::refreshProps() {
 	
 	lastNumProps = entity->entityProps.size();
 		
-	Resize(width, height);	
+	Resize(getWidth(), getHeight());	
 }
 
 void EntityPropSheet::Update() {
@@ -2026,7 +1926,7 @@ void ShaderOptionsSheet::setShader(Shader *shader, Material *material, ShaderBin
 	setOptionsFromParams(shader->expectedParams);
 	
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);	
-	Resize(width, height);
+	Resize(getWidth(), getHeight());
 }
 
 ShaderTexturesSheet::ShaderTexturesSheet() : PropSheet("SHADER TEXTURES", "shader_textures"){
@@ -2132,52 +2032,9 @@ void ShaderTexturesSheet::setShader(Shader *shader, Material *material, ShaderBi
 	}
 
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);	
-	Resize(width, height);
-}
-
-EntitySheet::EntitySheet() : PropSheet("SCREEN ENTITY", "screen_entity") {
-
-	widthProp = new NumberProp("Width");
-	addProp(widthProp);
-	
-	heightProp = new NumberProp("Height");
-	addProp(heightProp);
-	
-	propHeight = 100;
-	entity = NULL;
-	lastEntity = NULL;
+	Resize(getWidth(), getHeight());
 }
 
-EntitySheet::~EntitySheet() {
-
-}
-		
-void EntitySheet::handleEvent(Event *event) {
-	if(entity) {
-		if(event->getDispatcher() == widthProp) {
-			entity->setWidth(widthProp->get());
-			dispatchEvent(new Event(), Event::CHANGE_EVENT);		
-		} else 	if(event->getDispatcher() == heightProp) {
-			entity->setHeight(heightProp->get());
-			dispatchEvent(new Event(), Event::CHANGE_EVENT);		
-		}
-
-	}
-	PropSheet::handleEvent(event);	
-}
-
-void EntitySheet::Update() {
-	if(entity) {
-		enabled = true;
-		if(entity != lastEntity) {
-			widthProp->set(entity->getWidth());
-			heightProp->set(entity->getHeight());
-			lastEntity = entity;
-		}
-	} else {
-		enabled = false;
-	}
-}
 
 EntitySheet::EntitySheet() : PropSheet("ENTITY", "entity"){
 	idProp = new StringProp("ID");
@@ -2267,461 +2124,11 @@ void EntitySheet::Update() {
 	}
 }
 
-
-ScreenParticleSheet::ScreenParticleSheet() : PropSheet("PARTICLE EMITTER", "ScreenParticleEmitter") {
-
-	textureProp = new TextureProp("Texture");
-	addProp(textureProp);
-
-	blendingProp = new ComboProp("Blend mode");
-	addProp(blendingProp);
-	
-	blendingProp->comboEntry->addComboItem("Normal");
-	blendingProp->comboEntry->addComboItem("Lighten");
-	blendingProp->comboEntry->addComboItem("Color");
-	blendingProp->comboEntry->addComboItem("Premultiplied");
-	blendingProp->comboEntry->addComboItem("Multiply");
-
-	ignoreParentMatrixProp = new BoolProp("No parent matrix");
-	addProp(ignoreParentMatrixProp);
-	
-	numParticlesProp = new NumberProp("Num particles");
-	addProp(numParticlesProp);
-		
-	lifespanProp = new NumberProp("Lifespan (secs)");
-	addProp(lifespanProp);
-
-	particleScaleProp = new NumberProp("Size");
-	addProp(particleScaleProp);
-	
-	sizeProp = new Vector2Prop("Emitter size");
-	addProp(sizeProp);
-
-	dirProp = new Vector2Prop("Direction");
-	addProp(dirProp);
-
-	gravProp = new Vector2Prop("Gravity");
-	addProp(gravProp);
-
-	deviationProp = new Vector2Prop("Deviation");
-	addProp(deviationProp);
-
-	brightnessDeviationProp = new SliderProp("Brightness var", 0.0, 1.0);
-	addProp(brightnessDeviationProp);
-
-	perlinEnableProp = new BoolProp("Perlin mod");
-	addProp(perlinEnableProp);
-	
-	perlinModSizeProp = new NumberProp("Perlin size");
-	addProp(perlinModSizeProp);
-
-	speedModProp = new SliderProp("Speed mod", 0.0, 2.0);
-	addProp(speedModProp);
-
-	rotationSpeedProp = new NumberProp("Rot. speed");
-	addProp(rotationSpeedProp);
-	
-	rotationFollowsPathProp = new BoolProp("Auto-orient");
-	addProp(rotationFollowsPathProp);
-	
-	useScaleCurvesProp = new BoolProp("Scale curves");
-	addProp(useScaleCurvesProp);
-	
-	scaleCurveProp = new BezierCurveProp("Edit scale", "Scale");
-	addProp(scaleCurveProp);
-
-	useColorCurvesProp = new BoolProp("Color curves");
-	addProp(useColorCurvesProp);
-	
-	colorCurveProp = new BezierRGBACurveProp("Edit color");
-	addProp(colorCurveProp);
-	
-	emitter = NULL;
-	propHeight = 680;
-}
-
-void ScreenParticleSheet::handleEvent(Event *event) {
-
-	if(!emitter)
-		return;
-		
-	if(event->getDispatcher() == blendingProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		emitter->setParticleBlendingMode(blendingProp->get());
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-		
-
-	if(event->getDispatcher() == sizeProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastSize = Vector3(sizeProp->get().x, sizeProp->get().y, 0.0);
-		emitter->emitterRadius = lastSize;
-		emitter->resetAll();		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	if(event->getDispatcher() == dirProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastDir = Vector3(dirProp->get().x, dirProp->get().y, 0.0);
-		emitter->dirVector = lastDir;
-		emitter->resetAll();
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == gravProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastGrav = Vector3(gravProp->get().x, gravProp->get().y, 0.0);
-		emitter->gravVector = lastGrav;
-		emitter->resetAll();
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-
-	if(event->getDispatcher() == deviationProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastDeviation = Vector3(deviationProp->get().x, deviationProp->get().y, 0.0);
-		emitter->deviation = lastDeviation;
-		emitter->resetAll();		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	if(event->getDispatcher() == particleScaleProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastParticleScale = particleScaleProp->get();
-		emitter->particleSize = lastParticleScale;
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-
-	if(event->getDispatcher() == brightnessDeviationProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastBrightnessDeviation = brightnessDeviationProp->get();
-		emitter->brightnessDeviation = lastBrightnessDeviation;
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	if(event->getDispatcher() == perlinModSizeProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastPerlinSize = perlinModSizeProp->get();
-		emitter->perlinModSize = lastPerlinSize;
-		emitter->resetAll();		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-	
-	if(event->getDispatcher() == speedModProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastSpeedMod = speedModProp->get();
-		emitter->particleSpeedMod = lastSpeedMod;
-		emitter->resetAll();		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}		
-
-	if(event->getDispatcher() == perlinEnableProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastEnableProp = perlinEnableProp->get();
-		emitter->perlinEnabled = lastEnableProp;
-		emitter->resetAll();		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-	
-	if(event->getDispatcher() == lifespanProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastLifespan = lifespanProp->get();
-		emitter->lifespan = lastLifespan;
-		emitter->resetAll();
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}		
-
-	if(event->getDispatcher() == numParticlesProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastNumParticles = numParticlesProp->get();
-		emitter->setParticleCount(lastNumParticles);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	if(event->getDispatcher() == textureProp) {
-		Texture *selectedTexture = textureProp->previewShape->getTexture();		
-		emitter->setParticleTexture(selectedTexture);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}			
-
-	if(event->getDispatcher() == rotationSpeedProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastRotationSpeed = rotationSpeedProp->get();
-		emitter->rotationSpeed = lastRotationSpeed;		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-	
-	if(event->getDispatcher() == rotationFollowsPathProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastRotationFollowsPath = rotationFollowsPathProp->get();
-		emitter->rotationFollowsPath = lastRotationFollowsPath;		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-
-	if(event->getDispatcher() == ignoreParentMatrixProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastIgnoreParentMatrix = ignoreParentMatrixProp->get();
-		emitter->setIgnoreParentMatrix(lastIgnoreParentMatrix);		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}	
-	
-	if(event->getDispatcher() == useScaleCurvesProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastUseScaleCurves = useScaleCurvesProp->get();
-		emitter->useScaleCurves = lastUseScaleCurves;		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}		
-
-	if(event->getDispatcher() == useColorCurvesProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastUseColorCurves = useColorCurvesProp->get();
-		emitter->useColorCurves = lastUseColorCurves;		
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}		
-	
-	
-	PropSheet::handleEvent(event);
-}
-
-void ScreenParticleSheet::Update() {
-	if(emitter) {
-	
-		enabled = true;	
-	
-		if(emitter->emitterRadius != lastSize) {
-			sizeProp->set(Vector2(emitter->emitterRadius.x, emitter->emitterRadius.y));
-			lastSize = emitter->emitterRadius;
-		}
-		
-		if(emitter->dirVector != lastDir) {
-			dirProp->set(Vector2(emitter->dirVector.x, emitter->dirVector.y));
-			lastDir = emitter->dirVector;
-		}		
-
-		if(emitter->gravVector != lastGrav) {
-			gravProp->set(Vector2(emitter->gravVector.x, emitter->gravVector.y));
-			lastGrav = emitter->gravVector;
-		}		
-
-		if(emitter->deviation != lastDeviation) {
-			deviationProp->set(Vector2(emitter->emitterRadius.x, emitter->emitterRadius.y));
-			lastSize = emitter->emitterRadius;
-		}
-
-		if(emitter->getIgnoreParentMatrix() != lastIgnoreParentMatrix) {
-			ignoreParentMatrixProp->set(emitter->getIgnoreParentMatrix());
-			lastIgnoreParentMatrix = emitter->getIgnoreParentMatrix();
-		}
-				
-		if(emitter->brightnessDeviation != lastBrightnessDeviation) {
-			lastBrightnessDeviation = emitter->brightnessDeviation;
-			brightnessDeviationProp->set(lastBrightnessDeviation);
-		}
-
-		if(emitter->particleSize != lastParticleScale) {
-			lastParticleScale = emitter->particleSize;
-			particleScaleProp->set(lastParticleScale);
-		}
-		
-		if(emitter->perlinModSize != lastPerlinSize) {
-			lastPerlinSize = emitter->perlinModSize;
-			perlinModSizeProp->set(lastPerlinSize);
-		}
-
-		if(emitter->perlinEnabled != lastEnableProp) {
-			lastEnableProp = emitter->perlinEnabled;
-			perlinEnableProp->set(lastEnableProp);
-		}
-
-		if(emitter->particleSpeedMod != lastSpeedMod) {
-			lastSpeedMod = emitter->particleSpeedMod;
-			speedModProp->set(lastSpeedMod);
-		}
-
-		if(emitter->rotationSpeed != lastRotationSpeed) {
-			lastRotationSpeed = emitter->rotationSpeed;
-			rotationSpeedProp->set(lastRotationSpeed);
-		}
-		
-		if(emitter->lifespan != lastLifespan) {
-			lastLifespan = emitter->lifespan;
-			lifespanProp->set(lastLifespan);
-		}
-		
-		if(emitter->getNumParticles() != lastNumParticles) {
-			lastNumParticles = emitter->getNumParticles();
-			numParticlesProp->set(lastNumParticles);
-		}
-		
-		if(emitter->rotationFollowsPath != lastRotationFollowsPath) {
-			lastRotationFollowsPath = emitter->rotationFollowsPath;
-			rotationFollowsPathProp->set(lastRotationFollowsPath);
-		}
-		
-		
-		if(emitter->rotationFollowsPath != lastRotationFollowsPath) {
-			lastRotationFollowsPath = emitter->rotationFollowsPath;
-			rotationFollowsPathProp->set(lastRotationFollowsPath);
-		}
-		
-		if(emitter->useScaleCurves != lastUseScaleCurves) {
-			lastUseScaleCurves = emitter->useScaleCurves;
-			useScaleCurvesProp->set(lastUseScaleCurves);
-		}
-
-		if((&emitter->scaleCurve) != lastScaleCurve) {
-			lastScaleCurve = &emitter->scaleCurve;
-			scaleCurveProp->curve = lastScaleCurve;
-		}
-		
-		
-		if(emitter->useColorCurves != lastUseColorCurves) {
-			lastUseColorCurves = emitter->useColorCurves;
-			useColorCurvesProp->set(lastUseColorCurves);
-		}
-
-		blendingProp->set(emitter->getParticleBlendingMode());
-
-		colorCurveProp->curveR = &emitter->colorCurveR;
-		colorCurveProp->curveG = &emitter->colorCurveG;		
-		colorCurveProp->curveB = &emitter->colorCurveB;
-		colorCurveProp->curveA = &emitter->colorCurveA;			
-				
-		textureProp->set(emitter->getParticleTexture());
-		
-	} else {
-		enabled = false;
-	}
-}
-		
-
-ScreenParticleSheet::~ScreenParticleSheet() {
-
-}
-
-Transform2DSheet::Transform2DSheet() : PropSheet("2D TRANSFORM", "transform2d") {
-
-	positionProp = new Vector2Prop("Position");
-	addProp(positionProp);
-
-	scaleProp = new Vector2Prop("Scale");
-	addProp(scaleProp);
-
-	rotationProp = new NumberProp("Rotation (deg)");
-	addProp(rotationProp);
-
-	topLeftProp = new BoolProp("Topleft anchor");
-	addProp(topLeftProp);
-	
-	entity = NULL;
-	propHeight = 160;
-}
-
-void Transform2DSheet::handleEvent(Event *event) {
-
-	if(!entity)
-		return;
-
-	if(event->getDispatcher() == positionProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastPositon = positionProp->get();
-		entity->setPosition(lastPositon);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == scaleProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastScale = scaleProp->get();
-		entity->setScale(lastScale);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == rotationProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		lastRotation = rotationProp->get();
-		entity->setRotation(lastRotation);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-	if(event->getDispatcher() == topLeftProp  && event->getEventCode() == Event::CHANGE_EVENT) {
-		if(topLeftProp->get()) {
-			lastPositionMode = Entity::POSITION_TOPLEFT;
-			entity->setPositionMode(lastPositionMode);
-		} else {
-			lastPositionMode = Entity::POSITION_CENTER;
-			entity->setPositionMode(lastPositionMode);		
-		}
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-
-
-	PropSheet::handleEvent(event);
-}
-
-void Transform2DSheet::Update() {
-	if(entity) {
-	
-		enabled = true;	
-	
-		if(entity->getPosition2D() != lastPositon) {
-			positionProp->set(entity->getPosition2D());
-			lastPositon = entity->getPosition2D();
-		}
-		
-		if(entity->getScale2D() != lastScale) {
-			scaleProp->set(entity->getScale2D());
-			lastScale = entity->getScale2D();
-		}
-
-		if(entity->getPositionMode() != lastPositionMode) {
-			if(entity->getPositionMode() == Entity::POSITION_TOPLEFT) {
-				topLeftProp->set(true);
-			} else {
-				topLeftProp->set(false);			
-			}
-		
-			lastPositionMode = entity->getPositionMode();
-		}
-
-		
-		if(entity->getRotation() != lastRotation) {
-			lastRotation = entity->getRotation();
-			rotationProp->set(lastRotation);
-		}
-	} else {
-		enabled = false;
-	}
-}
-		
-
-Transform2DSheet::~Transform2DSheet() {
-
-}
-
-UIImageSheet::UIImageSheet() : PropSheet("SCREEN IMAGE", "UIImage") {
-	image = NULL;
-	
-	texture = new TextureProp("Texture");
-	texture->addEventListener(this, Event::CHANGE_EVENT);
-	addProp(texture);
-	
-	propHeight = 100;
-}
-
-UIImageSheet::~UIImageSheet() {
-
-}
-		
-void UIImageSheet::handleEvent(Event *event) {
-	if(!image)
-		return;
-
-	if(event->getDispatcher() == texture) {
-		Texture *selectedTexture = texture->previewShape->getTexture();
-		
-		image->setTexture(selectedTexture);
-		selectedTexture->reloadOnFileModify = true;
-		image->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, selectedTexture->getWidth(), selectedTexture->getHeight());
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
-	
-	PropSheet::handleEvent(event);
-}
-
-void UIImageSheet::Update() {
-	if(image) {
-		enabled = true;	
-		texture->set(image->getTexture());
-	} else {
-		enabled = false;
-	}
-}
-
-ScreenSpriteSheet::ScreenSpriteSheet() : PropSheet("SCREEN SPRITE", "ScreenSprite") {
+SceneSpriteSheet::SceneSpriteSheet() : PropSheet("SCREEN SPRITE", "SceneSprite") {
 	sprite = NULL;
 	lastSprite = NULL;
 	
-	spriteProp = new ScreenSpriteProp("Sprite");
+	spriteProp = new SceneSpriteProp("Sprite");
 	spriteProp->addEventListener(this, Event::CHANGE_EVENT);
 	addProp(spriteProp);	
 	
@@ -2732,11 +2139,11 @@ ScreenSpriteSheet::ScreenSpriteSheet() : PropSheet("SCREEN SPRITE", "ScreenSprit
 	propHeight = 140;
 }
 
-ScreenSpriteSheet::~ScreenSpriteSheet() {
+SceneSpriteSheet::~SceneSpriteSheet() {
 
 }
 		
-void ScreenSpriteSheet::handleEvent(Event *event) {
+void SceneSpriteSheet::handleEvent(Event *event) {
 	if(!sprite)
 		return;
 
@@ -2763,7 +2170,7 @@ void ScreenSpriteSheet::handleEvent(Event *event) {
 	PropSheet::handleEvent(event);
 }
 
-void ScreenSpriteSheet::Update() {
+void SceneSpriteSheet::Update() {
 	if(sprite) {	
 		if(lastSprite != sprite) {
 			defaultAnimationProp->comboEntry->clearItems();
@@ -2786,21 +2193,21 @@ void ScreenSpriteSheet::Update() {
 	}
 }
 
-EntityInstanceSheet::EntityInstanceSheet() : PropSheet("ENTITY INSTANCE", "EntityInstance") {
+SceneEntityInstanceSheet::SceneEntityInstanceSheet() : PropSheet("ENTITY INSTANCE", "SceneEntityInstance") {
 	instance = NULL;
 	
-	instanceProp = new EntityInstanceProp("Entity file");
+	instanceProp = new SceneEntityInstanceProp("Entity file");
 	instanceProp->addEventListener(this, Event::CHANGE_EVENT);
 	addProp(instanceProp);
 	
 	propHeight = 100;
 }
 
-EntityInstanceSheet::~EntityInstanceSheet() {
+SceneEntityInstanceSheet::~SceneEntityInstanceSheet() {
 
 }
 		
-void EntityInstanceSheet::handleEvent(Event *event) {
+void SceneEntityInstanceSheet::handleEvent(Event *event) {
 	if(!instance)
 		return;
 
@@ -2817,7 +2224,7 @@ void EntityInstanceSheet::handleEvent(Event *event) {
 	PropSheet::handleEvent(event);
 }
 
-void EntityInstanceSheet::Update() {
+void SceneEntityInstanceSheet::Update() {
 	if(instance) {
 		enabled = true;	
 		instanceProp->set(instance->getFileName());

IDE/Contents/Source/PolycodeScreenEditor.cpp

@@ -313,14 +313,10 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	sizePreviewShape = new ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 1, 1);
 	baseEntity->addChild(sizePreviewShape);
 	sizePreviewShape->setColor(1.0, 1.0, 1.0, 0.0);
-	sizePreviewShape->strokeEnabled = true;
-	sizePreviewShape->strokeColor = Color(1.0, 0.3, 0.0, 0.8);
 	
 	screenPreviewShape = new ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 1, 1);
 	baseEntity->addChild(screenPreviewShape);
 	screenPreviewShape->setColor(1.0, 1.0, 1.0, 0.0);
-	screenPreviewShape->strokeEnabled = true;
-	screenPreviewShape->strokeColor = Color(1.0, 1.0, 1.0, 0.5);
 
 	layerBaseEntity = new Entity();
 	layerBaseEntity->processInputEvents = true;
@@ -337,13 +333,13 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	previewEntity->billboardMode = true;
 	previewEntity->billboardIgnoreScale = true;
 	
-	previewSound = new ScreenSound("test.wav", 50, 100);
+	previewSound = new SceneSound("test.wav", 50, 100);
 	placingPreviewEntity->addChild(previewSound);
 				
 	createSoundRef(previewSound);
 
 	
-	previewEmitter = new ScreenParticleEmitter("default.png", Particle::BILLBOARD_PARTICLE, ParticleEmitter::CONTINUOUS_EMITTER, 2.0, 30, Vector3(0.0, -40.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(10.0, 10.0, 0.0));
+	previewEmitter = new SceneParticleEmitter("default.png", Particle::BILLBOARD_PARTICLE, ParticleEmitter::CONTINUOUS_EMITTER, 2.0, 30, Vector3(0.0, -40.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(10.0, 10.0, 0.0));
 	placingPreviewEntity->addChild(previewEmitter);
 	createParticleRef(previewEmitter);
 	
@@ -357,7 +353,7 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	previewLabel->setColor(1.0, 1.0, 1.0, 0.5);
 	previewLabel->positionAtBaseline = false;
 
-	previewSprite = new ScreenSprite("default/default.sprite");
+	previewSprite = new SceneSprite("default/default.sprite");
 	previewSprite->setAnchorPoint(0.0, 0.0, 0.0);	
 	placingPreviewEntity->addChild(previewSprite);
 	previewSprite->setColor(1.0, 1.0, 1.0, 0.5);
@@ -368,7 +364,7 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	placingPreviewEntity->addChild(previewImage);
 	previewImage->setColor(1.0, 1.0, 1.0, 0.5);
 
-	previewInstance = new EntityInstance("default/default.entity2d");
+	previewInstance = new SceneEntityInstance("default/default.entity2d");
 	previewInstance->setAnchorPoint(0.0, 0.0, 0.0);
 	placingPreviewEntity->addChild(previewInstance);
 	previewInstance->setColor(1.0, 1.0, 1.0, 0.5);
@@ -407,9 +403,9 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 
 
 	screenTransformShape = new ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 10, 10);
-	screenTransformShape->strokeColor = Color(0.0, 0.3, 1.0, 1.0);
+//	screenTransformShape->strokeColor = Color(0.0, 0.3, 1.0, 1.0);
 	screenTransformShape->lineSmooth = true;
-	screenTransformShape->strokeEnabled = true;
+//	screenTransformShape->strokeEnabled = true;
 	screenTransformShape->setColor(1.0, 1.0, 1.0, 0.0);
 	baseEntity->addChild(screenTransformShape);		
 
@@ -446,7 +442,7 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	transformScalerX = new UIImage("Images/ScreenEditor/transform_scaler.png");
 	transformScalerX->setColor(1.0, 0.5, 0.0, 0.7);
 	transformScalerX->setAnchorPoint(0.0, 0.0, 0.0);
-	transformScalerX->setRotation(90);
+	transformScalerX->setRoll(90);
 	transformScalerX->setPosition(50, 0);
 	screenTransform->addChild(transformScalerX);	
 	transformScalerX->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
@@ -457,7 +453,7 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	transformScalerXY = new UIImage("Images/ScreenEditor/transform_scaler.png");
 	transformScalerXY->setColor(1.0, 1.0, 1.0, 0.7);
 	transformScalerXY->setAnchorPoint(0.0, 0.0, 0.0);
-	transformScalerXY->setRotation(-45);
+	transformScalerXY->setRoll(-45);
 	transformScalerXY->setPosition(40, -40);
 	screenTransform->addChild(transformScalerXY);
 	transformScalerXY->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
@@ -741,12 +737,12 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	particleSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);		
 	entityProps->addPropSheet(particleSheet);
 
-	spriteSheet = new ScreenSpriteSheet();
+	spriteSheet = new SceneSpriteSheet();
 	spriteSheet->addEventListener(this, Event::CHANGE_EVENT);
 	spriteSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);	
 	entityProps->addPropSheet(spriteSheet);
 	
-	instanceSheet = new EntityInstanceSheet();
+	instanceSheet = new SceneEntityInstanceSheet();
 	instanceSheet->addEventListener(this, Event::CHANGE_EVENT);	
 	instanceSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
 	entityProps->addPropSheet(instanceSheet);
@@ -776,15 +772,11 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	transform2dSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);	
 	entityProps->addPropSheet(transform2dSheet);
 	
-	EntitySheet = new EntitySheet();
-	entityProps->addPropSheet(EntitySheet);
-	EntitySheet->addEventListener(this, Event::CHANGE_EVENT);	
-	EntitySheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
-				
 	entitySheet = new EntitySheet();
 	entityProps->addPropSheet(entitySheet);
+	entitySheet->addEventListener(this, Event::CHANGE_EVENT);	
 	entitySheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
-	
+					
 	entityPropSheet = new EntityPropSheet();
 	entityPropSheet->addEventListener(this, Event::CHANGE_EVENT);	
 	entityPropSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
@@ -795,7 +787,7 @@ PolycodeScreenEditorMain::PolycodeScreenEditorMain(PolycodeEditor *editor) {
 	parenting = false;
 	parentingChild = NULL;	
 	
-	parentingLine = new SceneLine(Vector2(), Vector2(0,0));
+	parentingLine = new SceneLine(Vector3(), Vector3(0,0,0));
 	parentingLine->setLineWidth(4.0);
 	parentingLine->setColor(0.0, 0.5, 1.0, 0.5);
 	baseEntity->addChild(parentingLine);
@@ -827,7 +819,7 @@ void PolycodeScreenEditorMain::setGrid(int gridSize) {
 		Mesh *gridMesh = new Mesh(Mesh::LINE_MESH);
 		gridMesh->addPolygon(gridPoly);
 	
-		grid = new ScreenMesh(gridMesh);
+		grid = new SceneMesh(gridMesh);
 		grid->setColor(1.0, 1.0, 1.0, 0.1);
 		objectBaseEntity->addChild(grid);		
 	}
@@ -855,7 +847,7 @@ void PolycodeScreenEditorMain::doAction(String actionName, PolycodeEditorActionD
 	} else if(actionName == "rotate") {
 		for(int i=0; i < selectedEntities.size(); i++) {
 			selectedEntities[i]->position = screenData->entries[i].vec3;		
-			selectedEntities[i]->setRotation(screenData->entries[i].number);
+			selectedEntities[i]->setRoll(screenData->entries[i].number);
 		}
 		syncTransformToSelected();			
 	} else if(actionName == "select") {
@@ -945,7 +937,7 @@ void PolycodeScreenEditorMain::syncTransformToSelected() {
 		screenTransform->rotation.roll = selectedEntity->getCombinedRoll();
 	} else {
 			
-		Vector2 center;
+		Vector3 center;
 		Number width;
 		Number height;
 		getCenterAndSizeForSelected(&center, &width, &height);
@@ -1197,7 +1189,7 @@ void PolycodeScreenEditorMain::handleMouseMove(Vector2 position) {
 				Number newAngle = atan2(diff.x, diff.y);				
 			
 				if(selectedEntities.size() == 1) {
-					selectedEntities[0]->setRotation(baseRotateAngles[0] - (TODEGREES * (newAngle-baseAngle)));
+					selectedEntities[0]->setRoll(baseRotateAngles[0] - (TODEGREES * (newAngle-baseAngle)));
 				} else {
 				
 					groupRoll = -(newAngle-baseAngle);
@@ -1207,7 +1199,7 @@ void PolycodeScreenEditorMain::handleMouseMove(Vector2 position) {
 						
 						Vector3 v3CenterRelative = selectedEntities[i]->getParentEntity()->getConcatenatedMatrixRelativeTo(baseEntity).Inverse() * v3Center;	
 						
-						selectedEntities[i]->setRotation(baseRotateAngles[i] - (TODEGREES * (newAngle-baseAngle)));						
+						selectedEntities[i]->setRoll(baseRotateAngles[i] - (TODEGREES * (newAngle-baseAngle)));						
 						
 						Number s = sin(newAngle-baseAngle);
 						Number c = cos(newAngle-baseAngle);
@@ -1483,14 +1475,14 @@ void PolycodeScreenEditorMain::handleMouseDown(Vector2 position) {
 		break;
 		case MODE_PARTICLES:
 		{
-				ScreenParticleEmitter *placingEmitter = new ScreenParticleEmitter("default.png", Particle::BILLBOARD_PARTICLE, ParticleEmitter::CONTINUOUS_EMITTER, 2.0, 30, Vector3(0.0, -40.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(10.0, 10.0, 0.0));
+				SceneParticleEmitter *placingEmitter = new SceneParticleEmitter("default.png", Particle::BILLBOARD_PARTICLE, ParticleEmitter::CONTINUOUS_EMITTER, 2.0, 30, Vector3(0.0, -40.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 0.0, 0.0), Vector3(10.0, 10.0, 0.0));
 
 				placingEmitter->setPosition(previewEmitter->getPosition2D());
 				placingEmitter->processInputEvents = true;
 				placingEmitter->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
 				placingEmitter->addEventListener(this, InputEvent::EVENT_MOUSEUP);				
 				currentLayer->addChild(placingEmitter);
-				placingEmitter->id = "ScreenParticleEmitter."+String::IntToString(placementCount);
+				placingEmitter->id = "SceneParticleEmitter."+String::IntToString(placementCount);
 				placingEmitter->blockMouseInput = true;				
 				placementCount++;	
 				
@@ -1546,13 +1538,13 @@ void PolycodeScreenEditorMain::handleMouseDown(Vector2 position) {
 		break;			
 		case MODE_SPRITE:
 		{
-				ScreenSprite *placingSprite = new ScreenSprite(previewSprite->getFileName());			
+				SceneSprite *placingSprite = new SceneSprite(previewSprite->getFileName());			
 				placingSprite->setPosition(previewSprite->getPosition2D());
 				placingSprite->processInputEvents = true;
 				placingSprite->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
 				placingSprite->addEventListener(this, InputEvent::EVENT_MOUSEUP);				
 				currentLayer->addChild(placingSprite);
-				placingSprite->id = "ScreenSprite."+String::IntToString(placementCount);
+				placingSprite->id = "SceneSprite."+String::IntToString(placementCount);
 				placingSprite->blockMouseInput = true;
 				placingSprite->getTexture()->reloadOnFileModify = true;
 				placingSprite->getResourceEntry()->reloadOnFileModify = true;
@@ -1579,7 +1571,7 @@ void PolycodeScreenEditorMain::handleMouseDown(Vector2 position) {
 		break;		
 		case MODE_LINK:
 		{
-				EntityInstance *placingInstance = new EntityInstance(previewInstance->getFileName());
+				SceneEntityInstance *placingInstance = new SceneEntityInstance(previewInstance->getFileName());
 				placingInstance->setPosition(previewInstance->getPosition2D());
 				placingInstance->processInputEvents = true;
 				placingInstance->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
@@ -1639,7 +1631,7 @@ void PolycodeScreenEditorMain::handleMouseDown(Vector2 position) {
 		{
 				Sound *sound = previewSound->getSound();
 				
-				ScreenSound *placingSound = new ScreenSound(sound->getFileName(), sound->getReferenceDistance(), sound->getMaxDistance());
+				SceneSound *placingSound = new SceneSound(sound->getFileName(), sound->getReferenceDistance(), sound->getMaxDistance());
 				placingSound->setPosition(previewSound->getPosition2D());
 				placingSound->processInputEvents = true;
 				placingSound->setAnchorPoint(0.0, 0.0, 0.0);
@@ -1648,7 +1640,7 @@ void PolycodeScreenEditorMain::handleMouseDown(Vector2 position) {
 				placingSound->setWidth(50);
 				placingSound->setHeight(50);				
 				currentLayer->addChild(placingSound);
-				placingSound->id = "ScreenSound."+String::IntToString(placementCount);
+				placingSound->id = "SceneSound."+String::IntToString(placementCount);
 				placingSound->blockMouseInput = true;	
 				placementCount++;
 				
@@ -1696,7 +1688,7 @@ void PolycodeScreenEditorMain::createEntityRef(Entity *entity) {
 	
 }
 
-void PolycodeScreenEditorMain::createParticleRef(ScreenParticleEmitter *target) {
+void PolycodeScreenEditorMain::createParticleRef(SceneParticleEmitter *target) {
 
 	UIImage *markerImage = new UIImage("Images/particle_system_icon_editor.png");
 	markerImage->addTag("editorRef");
@@ -1720,7 +1712,7 @@ void PolycodeScreenEditorMain::createParticleRef(ScreenParticleEmitter *target)
 		
 }
 
-void PolycodeScreenEditorMain::createSoundRef(ScreenSound *target) {
+void PolycodeScreenEditorMain::createSoundRef(SceneSound *target) {
 	UIImage *markerImage = new UIImage("Images/ScreenEditor/screen_sound_icon.png");
 	target->addChild(markerImage);
 	markerImage->setAnchorPoint(0.0, 0.0, 0.0);
@@ -1851,12 +1843,12 @@ void PolycodeScreenEditorMain::selectEntity(Entity *entity, bool doAction) {
 		}
 	}
 
-	if(dynamic_cast<ScreenParticleEmitter*>(entity)) {
-		particleSheet->emitter = (ScreenParticleEmitter*) entity;
+	if(dynamic_cast<SceneParticleEmitter*>(entity)) {
+		particleSheet->emitter = (SceneParticleEmitter*) entity;
 	}
 	
-	if(dynamic_cast<ScreenSprite*>(entity)) {
-		spriteSheet->sprite = (ScreenSprite*) entity;
+	if(dynamic_cast<SceneSprite*>(entity)) {
+		spriteSheet->sprite = (SceneSprite*) entity;
 	}
 	
 	if(dynamic_cast<ScenePrimitive*>(entity)) {
@@ -1872,12 +1864,12 @@ void PolycodeScreenEditorMain::selectEntity(Entity *entity, bool doAction) {
 		labelSheet->label = (SceneLabel*) entity;
 	}
 
-	if(dynamic_cast<ScreenSound*>(entity)) {
-		soundSheet->sound = ((ScreenSound*) entity);
+	if(dynamic_cast<SceneSound*>(entity)) {
+		soundSheet->sound = ((SceneSound*) entity);
 	}
 	
-	if(dynamic_cast<EntityInstance*>(entity) && entity != layerBaseEntity) {
-		instanceSheet->instance = ((EntityInstance*) entity);
+	if(dynamic_cast<SceneEntityInstance*>(entity) && entity != layerBaseEntity) {
+		instanceSheet->instance = ((SceneEntityInstance*) entity);
 	}
 			
 		
@@ -1963,7 +1955,7 @@ void PolycodeScreenEditorMain::deleteEntity(Entity *entity) {
 void PolycodeScreenEditorMain::handleEvent(Event *event) {
 
 	if(event->getEventCode() == Event::RESOURCE_RELOAD_EVENT && event->getEventType() == "") {
-			EntityInstanceResourceEntry *entry = dynamic_cast<EntityInstanceResourceEntry*>(event->getDispatcher());
+			SceneEntityInstanceResourceEntry *entry = dynamic_cast<SceneEntityInstanceResourceEntry*>(event->getDispatcher());
 			if(entry) {	
 				applyEditorProperties(entry->getInstance());
 				applyEditorOnlyChildren(entry->getInstance());				
@@ -2510,7 +2502,7 @@ void PolycodeScreenEditorMain::Resize(Number width, Number height) {
 		firstResize = false;
 	}
 	
-	UIElement::Resize(width, height);
+	UIElement::Resize(getWidth(), getHeight());
 }
 
 void PolycodeScreenEditorMain::handleDroppedFile(OSFileEntry file, Number x, Number y) {
@@ -2701,11 +2693,11 @@ void PolycodeScreenEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *
 		}
 	}
 
-	if(dynamic_cast<EntityInstance*>(entity) && entity != editorMain->layerBaseEntity) {
+	if(dynamic_cast<SceneEntityInstance*>(entity) && entity != editorMain->layerBaseEntity) {
 		if(!(*(entry))["type"])
-			entry->addChild("type", "EntityInstance");
-		EntityInstance *instance = (EntityInstance*) entity;
-		ObjectEntry *instanceEntry = entry->addChild("EntityInstance");		
+			entry->addChild("type", "SceneEntityInstance");
+		SceneEntityInstance *instance = (SceneEntityInstance*) entity;
+		ObjectEntry *instanceEntry = entry->addChild("SceneEntityInstance");		
 		instanceEntry->addChild("filePath", instance->getFileName());
 	}
 	
@@ -2718,13 +2710,13 @@ void PolycodeScreenEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *
 	}
 
 	
-	if(dynamic_cast<ScreenParticleEmitter*>(entity)) {
+	if(dynamic_cast<SceneParticleEmitter*>(entity)) {
 		if(!(*(entry))["type"])
-			entry->addChild("type", "ScreenParticleEmitter");
+			entry->addChild("type", "SceneParticleEmitter");
 			
-		ScreenParticleEmitter *emitter = (ScreenParticleEmitter*) entity;
+		SceneParticleEmitter *emitter = (SceneParticleEmitter*) entity;
 		
-		ObjectEntry *emitterEntry = entry->addChild("ScreenParticleEmitter");		
+		ObjectEntry *emitterEntry = entry->addChild("SceneParticleEmitter");		
 
 		emitterEntry->addChild("texturePath", emitter->getParticleTexture()->getResourcePath());
 		emitterEntry->addChild("radiusX", emitter->emitterRadius.x);
@@ -2767,12 +2759,12 @@ void PolycodeScreenEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *
 	}
 		
 	
-	if(dynamic_cast<ScreenSprite*>(entity)) {
+	if(dynamic_cast<SceneSprite*>(entity)) {
 		if(!(*(entry))["type"])
-			entry->addChild("type", "ScreenSprite");
-		ScreenSprite *sprite = (ScreenSprite*) entity;
+			entry->addChild("type", "SceneSprite");
+		SceneSprite *sprite = (SceneSprite*) entity;
 		
-		ObjectEntry *spriteEntry = entry->addChild("ScreenSprite");
+		ObjectEntry *spriteEntry = entry->addChild("SceneSprite");
 		spriteEntry->addChild("filePath", sprite->getFileName());
 		
 		String animName = "";
@@ -2794,12 +2786,12 @@ void PolycodeScreenEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *
 		labelEntry->addChild("aaMode", (int)label->getLabel()->getAntialiasMode());
 	}
 	
-	if(dynamic_cast<ScreenSound*>(entity)) {
-		ScreenSound *sound = (ScreenSound*) entity;
+	if(dynamic_cast<SceneSound*>(entity)) {
+		SceneSound *sound = (SceneSound*) entity;
 		
 		if(!(*(entry))["type"])
-			entry->addChild("type", "ScreenSound");
-		ObjectEntry *soundEntry = entry->addChild("ScreenSound");		
+			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());
@@ -2931,8 +2923,8 @@ void PolycodeScreenEditorMain::applyEditorProperties(Entity *entity) {
 		applyEditorProperties((Entity*)entity->getChildAtIndex(i));
 	}
 
-	if(dynamic_cast<EntityInstance*>(entity) && entity != layerBaseEntity) {
-		EntityInstance *instance = (((EntityInstance*)entity));
+	if(dynamic_cast<SceneEntityInstance*>(entity) && entity != layerBaseEntity) {
+		SceneEntityInstance *instance = (((SceneEntityInstance*)entity));
 		instance->cloneUsingReload = true;
 		applyEditorOnlyChildren(instance);
 		instance->getResourceEntry()->reloadOnFileModify = true;		
@@ -2940,8 +2932,8 @@ void PolycodeScreenEditorMain::applyEditorProperties(Entity *entity) {
 			instance->getResourceEntry()->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
 			CoreServices::getInstance()->getResourceManager()->addResource(instance->getResourceEntry());
 		}
-	} else if(dynamic_cast<ScreenSprite*>(entity)) {	
-		ScreenSprite *sprite = (((ScreenSprite*)entity));	
+	} else if(dynamic_cast<SceneSprite*>(entity)) {	
+		SceneSprite *sprite = (((SceneSprite*)entity));	
 		sprite->getResourceEntry()->reloadOnFileModify = true;
 		if(!CoreServices::getInstance()->getResourceManager()->hasResource(sprite->getResourceEntry())) { 
 			CoreServices::getInstance()->getResourceManager()->addResource(sprite->getResourceEntry());
@@ -2950,18 +2942,18 @@ void PolycodeScreenEditorMain::applyEditorProperties(Entity *entity) {
 	} else if(dynamic_cast<UIImage*>(entity)) {
 	} else if(dynamic_cast<SceneLabel*>(entity)) {
 
-	} else if(dynamic_cast<ScreenSound*>(entity)) {
-		createSoundRef((ScreenSound*)entity);
-	} else if(dynamic_cast<ScreenParticleEmitter*>(entity)) {
-		createParticleRef((ScreenParticleEmitter*)entity);		
+	} else if(dynamic_cast<SceneSound*>(entity)) {
+		createSoundRef((SceneSound*)entity);
+	} else if(dynamic_cast<SceneParticleEmitter*>(entity)) {
+		createParticleRef((SceneParticleEmitter*)entity);		
 	} else {	
 		if(entity != layerBaseEntity && entity->getEntityProp("editor_type") != "layer") {
 			createEntityRef(entity);
 		}
 	}
 	
-	if(dynamic_cast<ScreenMesh*>(entity)) {	
-		Texture *texture = ((ScreenMesh*)entity)->getTexture();
+	if(dynamic_cast<SceneMesh*>(entity)) {	
+		Texture *texture = ((SceneMesh*)entity)->getTexture();
 		if(texture) {
 			texture->reloadOnFileModify = true;
 		}
@@ -2980,7 +2972,7 @@ void PolycodeScreenEditorMain::applyEditorProperties(Entity *entity) {
 bool PolycodeScreenEditor::openFile(OSFileEntry filePath) {
 	PolycodeEditor::openFile(filePath);	
 		
-	EntityInstance *loadedInstance = new EntityInstance(filePath.fullPath);
+	SceneEntityInstance *loadedInstance = new SceneEntityInstance(filePath.fullPath);
 	
 	editorMain->layerBaseEntity = loadedInstance;
 	editorMain->objectBaseEntity->addChild(loadedInstance);
@@ -3030,8 +3022,8 @@ PropertiesSizer::~PropertiesSizer() {
 }
 
 void PropertiesSizer::Resize(Number width, Number height) {
-	sizer->Resize(width, height);
-	UIElement::Resize(width, height);
+	sizer->Resize(getWidth(), getHeight());
+	UIElement::Resize(getWidth(), getHeight());
 }
 
 

IDE/Contents/Source/PolycodeSpriteEditor.cpp

@@ -271,7 +271,7 @@ bool PolycodeSpriteEditor::openFile(OSFileEntry filePath) {
 					
 	initialLoad = true;
 	
-	previewSprite = new ScreenSprite(filePath.fullPath);
+	previewSprite = new SceneSprite(filePath.fullPath);
 	addChild(previewSprite);
 	previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
 	previewSprite->setPosition(400, 80);