Major changes all across, haven't been commiting anything, will start now

.gitignore

@@ -18,6 +18,7 @@ Bindings/Build/Mac\ OS\ X/build
 Core/Dependencies
 Modules/Dependencies
 IDE/Dependencies
+Tools/Dependencies
 
 # OS generated files #
 ######################

Core/Build/Mac OS X/PolyCore.xcodeproj/project.pbxproj

@@ -183,7 +183,6 @@
 		6DFBF46812A3184E00C43A7D /* tinyxml.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DFBF3B912A3184E00C43A7D /* tinyxml.cpp */; };
 		6DFBF46912A3184E00C43A7D /* tinyxmlerror.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DFBF3BA12A3184E00C43A7D /* tinyxmlerror.cpp */; };
 		6DFBF46A12A3184E00C43A7D /* tinyxmlparser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DFBF3BB12A3184E00C43A7D /* tinyxmlparser.cpp */; };
-		6DFBF46B12A3184E00C43A7D /* xmltest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DFBF3BC12A3184E00C43A7D /* xmltest.cpp */; };
 		6DFE5FC512D450C30005B100 /* PolyObject.h in Headers */ = {isa = PBXBuildFile; fileRef = 6DFE5FC412D450C30005B100 /* PolyObject.h */; };
 		6DFE5FC812D450CB0005B100 /* PolyObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6DFE5FC712D450CB0005B100 /* PolyObject.cpp */; };
 /* End PBXBuildFile section */
@@ -369,7 +368,6 @@
 		6DFBF3B912A3184E00C43A7D /* tinyxml.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tinyxml.cpp; sourceTree = "<group>"; };
 		6DFBF3BA12A3184E00C43A7D /* tinyxmlerror.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tinyxmlerror.cpp; sourceTree = "<group>"; };
 		6DFBF3BB12A3184E00C43A7D /* tinyxmlparser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = tinyxmlparser.cpp; sourceTree = "<group>"; };
-		6DFBF3BC12A3184E00C43A7D /* xmltest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = xmltest.cpp; sourceTree = "<group>"; };
 		6DFE5FC412D450C30005B100 /* PolyObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PolyObject.h; sourceTree = "<group>"; };
 		6DFE5FC712D450CB0005B100 /* PolyObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PolyObject.cpp; sourceTree = "<group>"; };
 		D2AAC046055464E500DB518D /* libPolyCore.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libPolyCore.a; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -613,7 +611,6 @@
 				6DFBF3B912A3184E00C43A7D /* tinyxml.cpp */,
 				6DFBF3BA12A3184E00C43A7D /* tinyxmlerror.cpp */,
 				6DFBF3BB12A3184E00C43A7D /* tinyxmlparser.cpp */,
-				6DFBF3BC12A3184E00C43A7D /* xmltest.cpp */,
 				6DFB017012A73BCF00C43A7D /* PolyModule.cpp */,
 			);
 			path = Source;
@@ -859,7 +856,6 @@
 				6DFBF46812A3184E00C43A7D /* tinyxml.cpp in Sources */,
 				6DFBF46912A3184E00C43A7D /* tinyxmlerror.cpp in Sources */,
 				6DFBF46A12A3184E00C43A7D /* tinyxmlparser.cpp in Sources */,
-				6DFBF46B12A3184E00C43A7D /* xmltest.cpp in Sources */,
 				6DFB017112A73BCF00C43A7D /* PolyModule.cpp in Sources */,
 				6D8656AB12AF5FD5008A486E /* PolyString.cpp in Sources */,
 				6D865AC412B0736C008A486E /* PolyData.cpp in Sources */,

Core/Contents/Include/PolyBezierCurve.h

@@ -25,7 +25,7 @@ namespace Polycode {
 
 	class _PolyExport BezierPoint {
 		public:
-		BezierPoint(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z);
+		BezierPoint(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z);
 		Vector3 p1;
 		Vector3 p2;
 		Vector3 p3;
@@ -39,30 +39,32 @@ namespace Polycode {
 		BezierPoint *getControlPoint(unsigned int index);
 		unsigned int getNumControlPoints();
 			
-		void addControlPoint(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z);
+		void addControlPoint(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z);
 
-		void addControlPoint3dWithHandles(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z);
-		void addControlPoint3d(float x, float y, float z);		
-		void addControlPoint2dWithHandles(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y);
-		void addControlPoint2d(float x, float y);
+		void addControlPoint3dWithHandles(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z);
+		void addControlPoint3d(Number x, Number y, Number z);		
+		void addControlPoint2dWithHandles(Number p1x, Number p1y, Number p2x, Number p2y, Number p3x, Number p3y);
+		void addControlPoint2d(Number x, Number y);
 		
-		float getHeightAt(float a);
+		Number getHeightAt(Number a);
 		
-		Vector3 getPointAt(float a);
-		inline Vector3 getPointBetween(float a, BezierPoint *bp1, BezierPoint *bp2);
+		Vector3 getPointAt(Number a);
+		inline Vector3 getPointBetween(Number a, BezierPoint *bp1, BezierPoint *bp2);
 			
 		void rebuildBuffers();
 		
+		Number heightBuffer[BUFFER_CACHE_PRECISION];
+
+		vector<BezierPoint*> controlPoints;
+		vector<Number> distances;
+		
+		
 		protected:
 		
 			bool buffersDirty;
 		
-			float heightBuffer[BUFFER_CACHE_PRECISION];
-		
 			void recalculateDistances();
 	
-			vector<BezierPoint*> controlPoints;
-			vector<float> distances;
 			
 	};
 

Core/Contents/Include/PolyBone.h

@@ -14,17 +14,16 @@
 #include "PolyString.h"
 #include "PolySceneEntity.h"
 #include "PolyMesh.h"
-#include "PolyFont.h"
 #include "PolyCoreServices.h"
 #include "PolySceneLabel.h"
-
+#include "PolySceneLine.h"
 namespace Polycode {
 
 	class _PolyExport Bone : public SceneEntity {
 		public:
 			Bone(String boneName);
 			~Bone();
-			void enableBoneLabel(Font *font, float size, float scale);
+			void enableBoneLabel(String labelFont, Number size, Number scale, Color labelColor);
 			String getName();
 			void Render();
 
@@ -41,17 +40,24 @@ namespace Polycode {
 			Matrix4 getParentRestMatrix();
 			Matrix4 getFinalMatrix();
 			void setRestMatrix(Matrix4 matrix);
-
+			void setBaseMatrix(Matrix4 matrix);
+			Matrix4 getBaseMatrix() { return baseMatrix; }
+			Matrix4 getFullBaseMatrix();
+		
 			int parentBoneId;			
+
+			Matrix4 boneMatrix;
+			Matrix4 restMatrix;
+			Matrix4 baseMatrix;
+		
+		
 		
 		protected:
+			Mesh *boneMesh;
 		
-			Matrix4 boneMatrix;
-			Matrix4 restMatrix;
 			Bone* parentBone;
 			vector<Bone*> childBones;
 			String boneName;
-			Mesh *boneMesh;
 	};
 
 }

Core/Contents/Include/PolyCamera.h

@@ -26,14 +26,14 @@ namespace Polycode {
 			~Camera();
 			
 			void buildFrustrumPlanes();
-			bool isSphereInFrustrum(Vector3 pos, float fRadius);
+			bool isSphereInFrustrum(Vector3 pos, Number fRadius);
 		
 			bool canSee(SceneEntity *entity);
 			
 			void setOrthoMode(bool mode);
 			bool getOrthoMode();
-			void setFOV(float fov);
-			float getFOV();
+			void setFOV(Number fov);
+			Number getFOV();
 			void doCameraTransform();
 
 			void setLightDepthTexture(Texture *texture);
@@ -43,18 +43,18 @@ namespace Polycode {
 			void drawFilter();
 			
 			
-			void setExposureLevel(float level);
-			float getExposureLevel();
+			void setExposureLevel(Number level);
+			Number getExposureLevel();
 			
 			void createPostFilter(Material *shaderMaterial);
 			void setPostFilter(String shaderName);
 			
 		private:
 		
-			float exposureLevel;
+			Number exposureLevel;
 			bool orthoMode;
-			float fov;
-			float frustumPlanes[6][4];
+			Number fov;
+			Number frustumPlanes[6][4];
 			Scene *parentScene;
 		
 			bool fovSet;

Core/Contents/Include/PolyColor.h

@@ -21,38 +21,38 @@ namespace Polycode {
 
 			Color();
 			Color(int r,int g, int b, int a);		
-			Color(float r,float g, float b, float a);
+			Color(Number r,Number g, Number b, Number a);
 			Color(Color *color);
 			Color(unsigned int hex);
 		
 			~Color();
 			
 			inline Color operator * ( const Color& v2)  {
-				float nr = r * v2.r;
-				float ng = g * v2.g;
-				float nb = b * v2.b;
-				float na = a * v2.a;				
+				Number nr = r * v2.r;
+				Number ng = g * v2.g;
+				Number nb = b * v2.b;
+				Number na = a * v2.a;				
 				return Color(nr, ng, nb, na);
 			}			
 			
 			void setColorHex(unsigned int hex);
 			void setColorHexRGB(unsigned int hex);
 		
-			void setColorHSV(float h, float s, float v);
+			void setColorHSV(Number h, Number s, Number v);
 			void setColorRGBA(int r, int g, int b, int a);
 			void setColorRGB(int r, int g, int b);
-			void setColor(float r, float g, float b, float a);
+			void setColor(Number r, Number g, Number b, Number a);
 			void setColor(Color *color);
 			void Random();
 		
-			float getBrightness();
+			Number getBrightness();
 			
 			unsigned int getUint();
 			
-			float r;
-			float g;
-			float b;
-			float a;
+			Number r;
+			Number g;
+			Number b;
+			Number a;
 		private:
 	
 	};

Core/Contents/Include/PolyConfig.h

@@ -26,7 +26,7 @@ namespace Polycode {
 	public:
 		String key;
 		String configNamespace;
-		float numVal;
+		Number numVal;
 		String stringVal;
 		bool isString;
 	};
@@ -42,9 +42,9 @@ namespace Polycode {
 		ConfigEntry *getEntry(String configNamespace, String key);
 		
 		void setStringValue(String configNamespace, String key, String value);
-		void setNumericValue(String configNamespace, String key, float value);		
+		void setNumericValue(String configNamespace, String key, Number value);		
 			
-		float getNumericValue(String configNamespace, String key);
+		Number getNumericValue(String configNamespace, String key);
 		String getStringValue(String configNamespace, String key);
 		
 	private:

Core/Contents/Include/PolyCore.h

@@ -72,15 +72,15 @@ namespace Polycode {
 		virtual String getClipboardString() = 0;
 		
 		CoreServices *getServices();
-		float getFPS();
+		Number getFPS();
 		void Shutdown();
 		
 		bool isFullscreen(){ return fullScreen; }
 		int getAALevel() { return aaLevel; }
 				
 		CoreInput *getInput();
-		float getXRes();
-		float getYRes();
+		Number getXRes();
+		Number getYRes();
 		
 		int getNumVideoModes();
 		virtual vector<Rectangle> getVideoModes() = 0;
@@ -100,8 +100,8 @@ namespace Polycode {
 		
 		void doSleep();
 		
-		float getElapsed();	
-		float getTicksFloat();
+		Number getElapsed();	
+		Number getTicksFloat();
 		
 		void setUserPointer(void *ptr) { userPointer = ptr; }
 		void *getUserPointer() { return userPointer; }
@@ -123,7 +123,7 @@ namespace Polycode {
 		int numVideoModes;
 		
 		bool running;
-		float fps;
+		Number fps;
 		unsigned int frameTicks;
 		unsigned int lastFrameTicks;
 		unsigned int lastFPSTicks;

Core/Contents/Include/PolyEntity.h

@@ -50,45 +50,45 @@ namespace Polycode {
 			void renderChildren();		
 
 			Vector3 *getPosition();
-			void setPosition(float x, float y, float z);
+			void setPosition(Number x, Number y, Number z);
 			
-			void setPositionX(float x);
-			void setPositionY(float y);
-			void setPositionZ(float z);
+			void setPositionX(Number x);
+			void setPositionY(Number y);
+			void setPositionZ(Number z);
 
-			void setScaleX(float x);
-			void setScaleY(float y);
-			void setScaleZ(float z);
+			void setScaleX(Number x);
+			void setScaleY(Number y);
+			void setScaleZ(Number z);
 		
 		
 			void setPosition(Vector3 posVec);
 		
-			void Translate(float x, float y, float z);
+			void Translate(Number x, Number y, Number z);
 			void Translate(Vector3 tVec);
-			void Scale(float x, float y, float z);
-			void setScale(float x, float y, float z);
+			void Scale(Number x, Number y, Number z);
+			void setScale(Number x, Number y, Number z);
 			Vector3 getScale();		
 		
 			Vector3 getCombinedPosition();
-			float getCombinedPitch();
-			float getCombinedYaw();
-			float getCombinedRoll();
+			Number getCombinedPitch();
+			Number getCombinedYaw();
+			Number getCombinedRoll();
 			void setParentEntity(Entity *entity);
 			Entity *getParentEntity();
 			void rebuildRotation();
 			void dirtyMatrix(bool val);
 		
-			void setPitch(float pitch);
-			void setYaw(float yaw);
-			void setRoll(float roll);
-			void Roll(float roll);
-			void Yaw(float roll);
-			void Pitch(float roll);
-			float getPitch();
-			float getYaw();
-			float getRoll();
-		
-			void setRotationQuat(float w, float x, float y, float z);
+			void setPitch(Number pitch);
+			void setYaw(Number yaw);
+			void setRoll(Number roll);
+			void Roll(Number roll);
+			void Yaw(Number roll);
+			void Pitch(Number roll);
+			Number getPitch();
+			Number getYaw();
+			Number getRoll();
+		
+			void setRotationQuat(Number w, Number x, Number y, Number z);
 			Quaternion getRotationQuat();
 		
 			Matrix4 getTransformMatrix();
@@ -101,14 +101,14 @@ namespace Polycode {
 			void setRenderer(Renderer *renderer);
 			
 			Color getCombinedColor();
-			void setColor(float r, float g, float b, float a);
+			void setColor(Number r, Number g, Number b, Number a);
 			void setColorInt(int r, int g, int b, int a);	
 			void setColor(Color color);
 		
 			void recalculateBBox();
-			float getBBoxRadius();
-			float getCompoundBBoxRadius();
-			void setBBoxRadius(float rad);			
+			Number getBBoxRadius();
+			Number getCompoundBBoxRadius();
+			void setBBoxRadius(Number rad);			
 			void setBlendingMode(int newBlendingMode);		
 			Vector3 getChildCenter();
 		
@@ -145,9 +145,14 @@ namespace Polycode {
 			bool enabled;
 			bool visible;
 		
+			bool depthWrite;		
+			bool depthTest;
+		
 			bool colorAffectsChildren;		
 			bool depthOnly;
 		
+			bool ignoreParentMatrix;
+		
 			// deprecated, remove!
 			bool maskByZbuffer;
 		
@@ -158,7 +163,7 @@ namespace Polycode {
 
 			int blendingMode;
 			Vector3 childCenter;
-			float bBoxRadius;		
+			Number bBoxRadius;		
 		
 			Vector3 position;
 			Vector3 scale;		
@@ -169,10 +174,10 @@ namespace Polycode {
 			bool matrixDirty;
 			Matrix4 transformMatrix;
 		
-			float matrixAdj;
-			float pitch;
-			float yaw;			
-			float roll;
+			Number matrixAdj;
+			Number pitch;
+			Number yaw;			
+			Number roll;
 		
 			Entity *parentEntity;
 		
@@ -183,7 +188,6 @@ namespace Polycode {
 		
 			Entity *maskEntity;
 		
-			bool depthWrite;		
 		
 			Renderer *renderer;
 	};

Core/Contents/Include/PolyGLES1Renderer.h

@@ -53,12 +53,12 @@ namespace Polycode {
 		void setPerspectiveMode();
 		
 		void enableBackfaceCulling(bool val);
-		void setViewportSize(int w, int h, float fov=45.0f);
+		void setViewportSize(int w, int h, Number fov=45.0f);
 		
 		void setLineSmooth(bool val);		
 		
 		void loadIdentity();
-		void setClearColor(float r, float g, float b);
+		void setClearColor(Number r, Number g, Number b);
 		
 		void setTexture(Texture *texture);		
 		void draw2DPolygon(Polygon *polygon);
@@ -68,29 +68,29 @@ namespace Polycode {
 		void renderZBufferToTexture(Texture *targetTexture);
 		void clearScreen();	
 		
-		void translate2D(float x, float y);
-		void rotate2D(float angle);
+		void translate2D(Number x, Number y);
+		void rotate2D(Number angle);
 		void scale2D(Vector2 *scale);
 		
-		void setLineSize(float lineSize);
+		void setLineSize(Number lineSize);
 		
-		void setVertexColor(float r, float g, float b, float a);
+		void setVertexColor(Number r, Number g, Number b, Number a);
 		
 		void setBlendingMode(int blendingMode);
 		
 		void enableLighting(bool enable);	
 		void enableFog(bool enable);
-		void setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth);		
+		void setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth);		
 		
 		void draw3DPolygon(Polygon *polygon);
 		void draw3DVertex(Vertex *vertex, Vector2 *faceUV);
 		void draw3DVertex2UV(Vertex *vertex, Vector2 *faceUV1, Vector2 *faceUV2);
-		void draw3DLine(Vector3 origin, Vector3 direction, float length, Color color);
+		void draw3DLine(Vector3 origin, Vector3 direction, Number length, Color color);
 		
 		virtual void setNormal(const Vector3 &normal);
 		
 		void translate3D(Vector3 *position);
-		void translate3D(float x, float y, float z);
+		void translate3D(Number x, Number y, Number z);
 		void scale3D(Vector3 *scale);
 		
 		Matrix4 getProjectionMatrix();
@@ -99,7 +99,7 @@ namespace Polycode {
 		void multModelviewMatrix(Matrix4 m);
 		
 		void enableDepthTest(bool val);		
-		void drawScreenQuad(float qx, float qy);
+		void drawScreenQuad(Number qx, Number qy);
 		
 		void beginRenderOperation(int meshType);
 		void endRenderOperation();
@@ -107,11 +107,11 @@ namespace Polycode {
 		void pushMatrix();
 		void popMatrix();
 		
-		bool test2DCoordinate(float x, float y, Polygon *poly, const Matrix4 &matrix, bool billboardMode);
+		bool test2DCoordinate(Number x, Number y, Polygon *poly, const Matrix4 &matrix, bool billboardMode);
 		
-		void setFOV(float fov);
+		void setFOV(Number fov);
 		
-		Vector3 Unproject(float x, float y);
+		Vector3 Unproject(Number x, Number y);
 		
 		void clearShader();
 		void applyMaterial(Material *material,  ShaderBinding *localOptions, unsigned int shaderIndex);
@@ -120,8 +120,8 @@ namespace Polycode {
 				
 		GLuint defaultFramebuffer, colorRenderbuffer;		
 		
-		float nearPlane;
-		float farPlane;
+		Number nearPlane;
+		Number farPlane;
 		
 		GLfloat sceneProjectionMatrix[16];
 		

Core/Contents/Include/PolyGLRenderer.h

@@ -122,19 +122,20 @@ namespace Polycode {
 		void pushRenderDataArray(RenderDataArray *array);
 		RenderDataArray *createRenderDataArrayForMesh(Mesh *mesh, int arrayType);
 		RenderDataArray *createRenderDataArray(int arrayType);
-		void setRenderArrayData(RenderDataArray *array, float *arrayData);
+		void setRenderArrayData(RenderDataArray *array, Number *arrayData);
 		void drawArrays(int drawType);		
 				
-		void setOrthoMode(float xSize=0.0f, float ySize=0.0f);
+		void setOrthoMode(Number xSize=0.0f, Number ySize=0.0f);
+		void _setOrthoMode();
 		void setPerspectiveMode();
 		
 		void enableBackfaceCulling(bool val);
-		void setViewportSize(int w, int h, float fov=45.0f);
+		void setViewportSize(int w, int h, Number fov=45.0f);
 		
 		void setLineSmooth(bool val);		
 		
 		void loadIdentity();
-		void setClearColor(float r, float g, float b);
+		void setClearColor(Number r, Number g, Number b);
 		
 		void setTexture(Texture *texture);		
 		
@@ -142,22 +143,22 @@ namespace Polycode {
 		void renderZBufferToTexture(Texture *targetTexture);
 		void clearScreen();	
 		
-		void translate2D(float x, float y);
-		void rotate2D(float angle);
+		void translate2D(Number x, Number y);
+		void rotate2D(Number angle);
 		void scale2D(Vector2 *scale);
 		
-		void setLineSize(float lineSize);
+		void setLineSize(Number lineSize);
 		
-		void setVertexColor(float r, float g, float b, float a);
+		void setVertexColor(Number r, Number g, Number b, Number a);
 		
 		void setBlendingMode(int blendingMode);
 		
 		void enableLighting(bool enable);	
 		void enableFog(bool enable);
-		void setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth);		
+		void setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth);		
 				
 		void translate3D(Vector3 *position);
-		void translate3D(float x, float y, float z);
+		void translate3D(Number x, Number y, Number z);
 		void scale3D(Vector3 *scale);
 		
 		Matrix4 getProjectionMatrix();
@@ -166,20 +167,21 @@ namespace Polycode {
 		void multModelviewMatrix(Matrix4 m);
 		
 		void enableDepthTest(bool val);
+		void enableDepthWrite(bool val);
 				
 		void clearBuffer(bool colorBuffer, bool depthBuffer);	
 		void drawToColorBuffer(bool val);
 		
-		void drawScreenQuad(float qx, float qy);
+		void drawScreenQuad(Number qx, Number qy);
 				
 		void pushMatrix();
 		void popMatrix();
 		
-		bool test2DCoordinate(float x, float y, Polycode::Polygon *poly, const Matrix4 &matrix, bool billboardMode);
+		bool test2DCoordinate(Number x, Number y, Polycode::Polygon *poly, const Matrix4 &matrix, bool billboardMode);
 		
-		void setFOV(float fov);
+		void setFOV(Number fov);
 		
-		Vector3 Unproject(float x, float y);
+		Vector3 Unproject(Number x, Number y);
 		
 		void setDepthFunction(int depthFunction);
 						
@@ -189,8 +191,8 @@ namespace Polycode {
 	protected:
 
 		
-		float nearPlane;
-		float farPlane;
+		Number nearPlane;
+		Number farPlane;
 		
 		int verticesToDraw;
 		

Core/Contents/Include/PolyGenericScene.h

@@ -35,7 +35,7 @@ namespace Polycode {
 	
 			static String readString(OSFILE *inFile);
 			void loadScene(String fileName);
-			void generateLightmaps(float lightMapRes, float lightMapQuality, int numRadPasses);
+			void generateLightmaps(Number lightMapRes, Number lightMapQuality, int numRadPasses);
 
 			void addLight(SceneLight *light);
 			SceneLight *getNearestLight(Vector3 pos);

Core/Contents/Include/PolyGlobals.h

@@ -65,3 +65,6 @@
 #define PACKET_TYPE_DISONNECT 3
 #define PACKET_TYPE_CLIENT_DATA 4
 
+
+typedef double Number;
+

Core/Contents/Include/PolyImage.h

@@ -35,10 +35,10 @@ namespace Polycode {
 		
 			
 			void createEmpty(unsigned int width, unsigned int height);
-			void fill(float r, float g, float b, float a);
+			void fill(Number r, Number g, Number b, Number a);
 			
 			// drawing
-			void setPixel(int x, int y, float r, float g, float b, float a);
+			void setPixel(int x, int y, Number r, Number g, Number b, Number a);
 			void setPixel(int x, int y, Color col);
 			Color getPixel(int x, int y);
 						   
@@ -55,9 +55,9 @@ namespace Polycode {
 			void fastBlur(int blurSize);
 			void fastBlurVert(int blurSize);
 			void fastBlurHor(int blurSize);
-			void darken(float amt, bool color, bool alpha);
-			void lighten(float amt, bool color, bool alpha);
-			void multiply(float amt, bool color, bool alpha);
+			void darken(Number amt, bool color, bool alpha);
+			void lighten(Number amt, bool color, bool alpha);
+			void multiply(Number amt, bool color, bool alpha);
 			
 			int getBrushX();
 			int getBrushY();

Core/Contents/Include/PolyLabel.h

@@ -34,8 +34,8 @@ namespace Polycode {
 			int getTextWidth(Font *font, String text, int size);
 			int getTextHeight(Font *font, String text, int size);
 					
-			float getTextWidth();		
-			float getTextHeight();
+			Number getTextWidth();		
+			Number getTextHeight();
 		
 			Font *getFont();
 					
@@ -44,8 +44,8 @@ namespace Polycode {
 			
 		private:
 
-			float currentTextWidth;
-			float currentTextHeight;
+			Number currentTextWidth;
+			Number currentTextHeight;
 			int antiAliasMode;
 			int size;
 			String text;

Core/Contents/Include/PolyMaterialManager.h

@@ -41,7 +41,7 @@ namespace Polycode {
 			Texture *createTexture(int width, int height, char *imageData, bool clamp=true, int type=Image::IMAGE_RGBA);
 			Texture *createNewTexture(int width, int height, bool clamp=true, int type=Image::IMAGE_RGBA);
 			Texture *createTextureFromImage(Image *image, bool clamp=true);
-			Texture *createTextureFromFile(String fileName);
+			Texture *createTextureFromFile(String fileName, bool clamp=true);
 			void deleteTexture(Texture *texture);
 		
 			void reloadTextures();

Core/Contents/Include/PolyMatrix4.h

@@ -25,10 +25,10 @@ namespace Polycode {
 
 
         inline Matrix4(
-            float m00, float m01, float m02, float m03,
-            float m10, float m11, float m12, float m13,
-            float m20, float m21, float m22, float m23,
-            float m30, float m31, float m32, float m33 )
+            Number m00, Number m01, Number m02, Number m03,
+            Number m10, Number m11, Number m12, Number m13,
+            Number m20, Number m21, Number m22, Number m23,
+            Number m30, Number m31, Number m32, Number m33 )
         {
             m[0][0] = m00;
             m[0][1] = m01;
@@ -49,18 +49,18 @@ namespace Polycode {
         }
 
 			
-			Matrix4(float *m);
+			Matrix4(Number *m);
 			~Matrix4();
 			
 			void init();
 			
 			union {
-				float m[4][4];
-				float ml[16];
+				Number m[4][4];
+				Number ml[16];
 			};
 			
 			inline void identity() {
-				memset(ml, 0, sizeof(float)*16);
+				memset(ml, 0, sizeof(Number)*16);
 				ml[0] = 1;
 				ml[5] = 1;
 				ml[10] = 1;
@@ -93,16 +93,22 @@ namespace Polycode {
 								v2.x*m[0][2] + v2.y*m[1][2] + v2.z*m[2][2] + m[3][2]);
 			}			
 			
-			inline float* operator [] ( int row ) { return m[row];}
+			inline Number* operator [] ( int row ) { return m[row];}
 
-			inline void setPosition(float x, float y, float z) {
+			inline void setPosition(Number x, Number y, Number z) {
 				m[3][0] = x;
 				m[3][1] = y;
 				m[3][2] = z;
 			}
+		
+			inline void setScale(Vector3 scale) {
+				m[0][0] = scale.x;
+				m[1][1] = scale.y;
+				m[2][2] = scale.z;
+			}
 
-			inline void getEulerAngles(float *ax, float *ay, float *az) {
-				float angle_x, angle_y, angle_z,tr_x,tr_y,C;
+			inline void getEulerAngles(Number *ax, Number *ay, Number *az) {
+				Number angle_x, angle_y, angle_z,tr_x,tr_y,C;
 				
 				angle_y = asin(m[0][2]);
 				

Core/Contents/Include/PolyMesh.h

@@ -31,6 +31,7 @@ namespace Polycode {
 			int getVertexCount() { return vertexCount;}
 		
 			int verticesPerFace;
+			int meshType;
 		protected:
 		int vertexCount;
 			
@@ -52,6 +53,13 @@ namespace Polycode {
 	};
 		
 
+	typedef struct {
+		float x;
+		float y;
+		float z;
+		float w;		
+	} Vector4_struct;
+	
 	typedef struct {
 		float x;
 		float y;
@@ -63,16 +71,6 @@ namespace Polycode {
 		float y;
 	} Vector2_struct;
 	
-	typedef struct {
-		unsigned int v1;
-		unsigned int v2;
-		unsigned int v3;
-		float nx;
-		float ny;
-		float nz;
-		Vector2_struct uvs[3];
-	} Face_struct;
-
 	class _PolyExport Mesh {
 		public:
 			Mesh(String fileName);
@@ -89,13 +87,15 @@ namespace Polycode {
 			unsigned int getPolygonCount();
 			Polygon *getPolygon(unsigned int index);
 					
-			void createPlane(float w, float h);
-			void createBox(float w, float d, float h);
-			void createSphere(float radius, float numRings, float numSegments);
+			void createPlane(Number w, Number h);
+			void createBox(Number w, Number d, Number h);
+			void createSphere(Number radius, Number numRings, Number numSegments);
 		
 			void addVertex(Vertex* vertex);
 			Vertex *getVertex(unsigned int index);
 			unsigned int getNumVertices();
+				
+			Vector3 recenterMesh();
 		
 			void useVertexNormals(bool val);
 			int getVertexIndex(Vertex *vertex);
@@ -104,7 +104,7 @@ namespace Polycode {
 			VertexBuffer *getVertexBuffer();
 		
 			bool usesFaceUV() { return useFaceUV; }
-			float getRadius();
+			Number getRadius();
 			
 			void calculateNormals();	
 			
@@ -120,7 +120,8 @@ namespace Polycode {
 			static const int TRIFAN_MESH = 2;
 			static const int TRISTRIP_MESH = 3;
 			static const int LINE_MESH = 4;
-
+			static const int POINT_MESH = 5;
+		
 			unsigned int numUVs;			
 					
 			bool arrayDirtyMap[16];

Core/Contents/Include/PolyObject.h

@@ -14,7 +14,7 @@ namespace Polycode {
 		int type;
 		String name;
 		
-		float floatVal;
+		Number NumberVal;
 		int intVal;
 		String stringVal;
 		bool boolVal;		
@@ -30,10 +30,10 @@ namespace Polycode {
 		}
 		
 		
-		ObjectEntry *addChild(String name, float val) {
+		ObjectEntry *addChild(String name, Number val) {
 			ObjectEntry *entry = new ObjectEntry();
 			entry->type = ObjectEntry::FLOAT_ENTRY;			
-			entry->floatVal = val;
+			entry->NumberVal = val;
 			entry->name = name;
 			children.push_back(entry);
 			length = children.size();			

Core/Contents/Include/PolyParticle.h

@@ -23,9 +23,9 @@ namespace Polycode {
 		public:
 			Particle(int particleType, bool isScreenParticle, Material *material, Texture *texture, Mesh *particleMesh);
 			~Particle();
-			void Reset();
+			void Reset(bool continuious);
 			
-			void createSceneParticle(int particleType, Material *material, Mesh *particleMesh);
+			void createSceneParticle(int particleType, Texture *texture, Mesh *particleMesh);
 			void createScreenParticle(int particleType, Texture *texture, Mesh *particleMesh);
 		
 			Entity *particleBody;						
@@ -33,12 +33,12 @@ namespace Polycode {
 			Vector3 velVector;
 			Vector3 dirVector;	
 			Vector3 deviation;		
-			float life;
-			float lifespan;
-			float brightnessDeviation;
-			float perlinPosX;
-			float perlinPosY;
-			float perlinPosZ;
+			Number life;
+			Number lifespan;
+			Number brightnessDeviation;
+			Number perlinPosX;
+			Number perlinPosY;
+			Number perlinPosZ;
 			
 			static const int BILLBOARD_PARTICLE = 0;
 			static const int MESH_PARTICLE = 1;

Core/Contents/Include/PolyParticleEmitter.h

@@ -24,16 +24,17 @@ using std::vector;
 namespace Polycode {
 	class _PolyExport ParticleEmitter {
 		public:
-			ParticleEmitter(String imageFile, Mesh *particleMesh, int particleType, int emitterType, float lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation);
+			ParticleEmitter(String imageFile, Mesh *particleMesh, int particleType, int emitterType, Number lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation);
 			virtual ~ParticleEmitter();
 		
 			void createParticles();
 			
-			void setRotationSpeed(float speed);
+			void setRotationSpeed(Number speed);
 			void setStartingColor(Color c);
 			void setEndingColor(Color c);
 			void setParticleBlendingMode(int mode);
 			void setDepthWrite(bool val);
+			void setDepthTest(bool val);		
 			void setAlphaTest(bool val);
 		
 			void enablePerlin(bool val);
@@ -41,9 +42,9 @@ namespace Polycode {
 			void enableEmitter(bool val);
 			bool emitterEnabled();
 			
-			void setEmitterRadius(float rad);
-			void setStartingScaleModifier(float mod);
-			void setEndingScaleModifier(float mod);
+			void setEmitterRadius(Number rad);
+			void setStartingScaleModifier(Number mod);
+			void setEndingScaleModifier(Number mod);
 			void setEmitRotationVector(Vector3 rotVector);
 			void setEmitRotationDeviance(Vector3 rotVector);
 			void setAllAtOnce(bool val);
@@ -51,14 +52,14 @@ namespace Polycode {
 			void Trigger();
 			void resetParticle(Particle *particle);
 			
-			void setPerlinModSize(float size);
+			void setPerlinModSize(Number size);
 			void setParticleCount(int count);
 		
 			virtual void addParticleBody(Entity *particleBody) = 0;
 			virtual Matrix4 getBaseMatrix() = 0;
 		
-			float particleSpeedMod;
-			float brightnessDeviation;
+			Number particleSpeedMod;
+			Number brightnessDeviation;
 			
 			void updateEmitter();
 
@@ -70,7 +71,7 @@ namespace Polycode {
 			Vector3 dirVector;
 			Vector3 gravVector;			
 
-			float lifespan;
+			Number lifespan;
 		
 			bool rotationFollowsPath;
 		
@@ -98,28 +99,42 @@ namespace Polycode {
 		
 			Vector3 emitRotationVector;
 			Vector3 emitRotationDeviance;
-			float emitterRadius;
-			float perlinModSize;
+			Number emitterRadius;
+			Number perlinModSize;
 			Perlin *motionPerlin;
 			bool perlinEnabled;
-			float startingScaleMod;
-			float endingScaleMod;
+			Number startingScaleMod;
+			Number endingScaleMod;
 			
 			Color startingColor;
 			Color endingColor;
 			
-			float rotationSpeed;
-			float numParticles;
+			Number rotationSpeed;
+			Number numParticles;
 			vector<Particle*> particles;
 			
-			float emitSpeed;
+			Number emitSpeed;
 			Timer *timer;
 	};
 
+	class _PolyExport SceneParticleEmitter : public SceneEntity, public ParticleEmitter {
+	public:
+		SceneParticleEmitter(String imageFile, Mesh *particleMesh, SceneMesh *emitter, Scene *particleParentScene, int particleType, int emitterType, Number lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation);
+		~SceneParticleEmitter();		
+		
+		void addParticleBody(Entity *particleBody);
+		Matrix4 getBaseMatrix();
+		void Update();
+		
+	protected:
+		SceneMesh *emitterMesh;		
+		Scene *particleParentScene;
+	};	
+	
 	
 	class _PolyExport ScreenParticleEmitter : public ScreenEntity, public ParticleEmitter {
 	public:
-		ScreenParticleEmitter(String imageFile, Mesh *particleMesh, ScreenMesh *emitter, Screen *particleParentScreen, int particleType, int emitterType, float lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation);
+		ScreenParticleEmitter(String imageFile, Mesh *particleMesh, ScreenMesh *emitter, Screen *particleParentScreen, int particleType, int emitterType, Number lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation);
 		~ScreenParticleEmitter();		
 		
 		void addParticleBody(Entity *particleBody);

Core/Contents/Include/PolyPerlin.h

@@ -21,37 +21,37 @@ class _PolyExport Perlin
 {
 public:
 
-  Perlin(int octaves,float freq,float amp,int seed);
+  Perlin(int octaves,Number freq,Number amp,int seed);
 
 
-  float Get(float x,float y)
+  Number Get(Number x,Number y)
   {
-    float vec[2];
+    Number vec[2];
     vec[0] = x;
     vec[1] = y;
     return perlin_noise_2D(vec);
   };
 
 private:
-  void init_perlin(int n,float p);
-  float perlin_noise_2D(float vec[2]);
-
-  float noise1(float arg);
-  float noise2(float vec[2]);
-  float noise3(float vec[3]);
-  void normalize2(float v[2]);
-  void normalize3(float v[3]);
+  void init_perlin(int n,Number p);
+  Number perlin_noise_2D(Number vec[2]);
+
+  Number noise1(Number arg);
+  Number noise2(Number vec[2]);
+  Number noise3(Number vec[3]);
+  void normalize2(Number v[2]);
+  void normalize3(Number v[3]);
   void init(void);
 
   int   mOctaves;
-  float mFrequency;
-  float mAmplitude;
+  Number mFrequency;
+  Number mAmplitude;
   int   mSeed;
 
   int p[SAMPLE_SIZE + SAMPLE_SIZE + 2];
-  float g3[SAMPLE_SIZE + SAMPLE_SIZE + 2][3];
-  float g2[SAMPLE_SIZE + SAMPLE_SIZE + 2][2];
-  float g1[SAMPLE_SIZE + SAMPLE_SIZE + 2];
+  Number g3[SAMPLE_SIZE + SAMPLE_SIZE + 2][3];
+  Number g2[SAMPLE_SIZE + SAMPLE_SIZE + 2][2];
+  Number g1[SAMPLE_SIZE + SAMPLE_SIZE + 2];
   bool  mStart;
 
 };

Core/Contents/Include/PolyPolygon.h

@@ -34,13 +34,16 @@ namespace Polycode {
 			
 			unsigned int getVertexCount();
 			Vertex *getVertex(unsigned int index);
-			Vertex *addVertex(float x, float y, float z);
-			void addTexCoord(float u, float v);
-			void addTexCoord2(float u, float v);
+			Vertex *addVertex(Number x, Number y, Number z);
+			
+			void removeVertex(int index);
+		
+			void addTexCoord(Number u, Number v);
+			void addTexCoord2(Number u, Number v);
 			Vector2 *getTexCoord(int index);
 			Vector2 *getTexCoord2(int index);
 			void addVertex(Vertex *vertex);
-			Vertex *addVertex(float x, float y, float z, float u, float v);
+			Vertex *addVertex(Number x, Number y, Number z, Number u, Number v);
 			void calculateNormal();
 			
 			Vector3 getFaceNormal();

Core/Contents/Include/PolyQuaternion.h

@@ -20,15 +20,15 @@ namespace Polycode {
 
 	class _PolyExport Quaternion {
 		public:
-			Quaternion(float w, float x, float y, float z) {
+			Quaternion(Number w, Number x, Number y, Number z) {
 				set(w,x,y,z);
 			}
 			Quaternion();
 			~Quaternion();
 		
 		inline void setFromMatrix(const Matrix4 &kRot) {
-			float fTrace = kRot.m[0][0]+kRot.m[1][1]+kRot.m[2][2];
-			float fRoot;
+			Number fTrace = kRot.m[0][0]+kRot.m[1][1]+kRot.m[2][2];
+			Number fRoot;
 			
 			if ( fTrace > 0.0 )
 			{
@@ -53,7 +53,7 @@ namespace Polycode {
 				size_t k = s_iNext[j];
 				
 				fRoot = sqrtf(kRot.m[i][i]-kRot.m[j][j]-kRot.m[k][k] + 1.0);
-				float* apkQuat[3] = { &x, &y, &z };
+				Number* apkQuat[3] = { &x, &y, &z };
 				*apkQuat[i] = 0.5*fRoot;
 				fRoot = 0.5/fRoot;
 				w = (kRot.m[k][j]-kRot.m[j][k])*fRoot;
@@ -62,15 +62,15 @@ namespace Polycode {
 			}			
 		}
 			
-			static Quaternion Slerp(float fT, const Quaternion& rkP, const Quaternion& rkQ, bool shortestPath=false);
-			float Dot(const Quaternion& rkQ) const;
+			static Quaternion Slerp(Number fT, const Quaternion& rkP, const Quaternion& rkQ, bool shortestPath=false);
+			Number Dot(const Quaternion& rkQ) const;
 	Quaternion Log () const;
     Quaternion Exp () const;	
-    float Norm () const;
-    float normalise(void);	
+    Number Norm () const;
+    Number normalise(void);	
     Quaternion operator+ (const Quaternion& rkQ) const;
     Quaternion operator* (const Quaternion& rkQ) const;
-    Quaternion operator* (float fScalar) const;
+    Quaternion operator* (Number fScalar) const;
 		
 		inline void lookAt(const Vector3 &D, const Vector3 &upVector) {
 			/*
@@ -89,7 +89,7 @@ namespace Polycode {
 		}
 		
 		void createFromMatrix(Matrix4 matrix) {
-			float  tr, s, q[4];
+			Number  tr, s, q[4];
 			int    i, j, k;
 			
 			static const int nxt[3] = {1, 2, 0};			
@@ -148,7 +148,7 @@ namespace Polycode {
 	}
 
 
-    static Quaternion Squad(float fT, const Quaternion& rkP, const Quaternion& rkA, const Quaternion& rkB, const Quaternion& rkQ, bool shortestPath);
+    static Quaternion Squad(Number fT, const Quaternion& rkP, const Quaternion& rkA, const Quaternion& rkB, const Quaternion& rkQ, bool shortestPath);
 	Quaternion Inverse () const;
 	
     Quaternion operator- () const
@@ -156,7 +156,7 @@ namespace Polycode {
         return Quaternion(-w,-x,-y,-z);
     }
 			
-			void set(float w, float x, float y, float z) {
+			void set(Number w, Number x, Number y, Number z) {
 				this->w = w;
 				this->x = x;
 				this->y = y;
@@ -164,33 +164,33 @@ namespace Polycode {
 			}
 			
 			Quaternion inverse() {
-				float fNorm = w*w+x*x+y*y+z*z;
-				float fInvNorm = 1.0/fNorm;
+				Number fNorm = w*w+x*x+y*y+z*z;
+				Number fInvNorm = 1.0/fNorm;
 				return Quaternion(w*fInvNorm,-x*fInvNorm,-y*fInvNorm,-z*fInvNorm);
 
 			}
 			
-	float InvSqrt(float x){
-   float xhalf = 0.5f * x;
-   int i = *(int*)&x; // store floating-point bits in integer
+	Number InvSqrt(Number x){
+   Number xhalf = 0.5f * x;
+   int i = *(int*)&x; // store Numbering-point bits in integer
    i = 0x5f3759d5 - (i >> 1); // initial guess for Newton's method
-   x = *(float*)&i; // convert new bits into float
+   x = *(Number*)&i; // convert new bits into Number
    x = x*(1.5f - xhalf*x*x); // One round of Newton's method
    return x;
 }
 		
-	inline void fromAxes(float az, float ay, float ax) {
+	inline void fromAxes(Number az, Number ay, Number ax) {
 		ax *= TORADIANS;
 		ay *= TORADIANS;
 		az *= TORADIANS;		
 		
-		float c1 = cos(ay / 2.0f);
-		float c2 = cos(ax / 2.0f);
-		float c3 = cos(az / 2.0f);
+		Number c1 = cos(ay / 2.0f);
+		Number c2 = cos(ax / 2.0f);
+		Number c3 = cos(az / 2.0f);
 		
-		float s1 = sin(ay / 2.0f);
-		float s2 = sin(ax / 2.0f);
-		float s3 = sin(az / 2.0f);
+		Number s1 = sin(ay / 2.0f);
+		Number s2 = sin(ax / 2.0f);
+		Number s3 = sin(az / 2.0f);
 		
 		w = (c1*c2*c3) - (s1*s2*s3);
 		x = (s1*s2*c3) + (c1*c2*s3);
@@ -199,27 +199,27 @@ namespace Polycode {
 	}
 			
 			
-    void FromAngleAxis (const float& rfAngle,
+    void FromAngleAxis (const Number& rfAngle,
         const Vector3& rkAxis)
     {
-        float fHalfAngle ( 0.5*rfAngle );
-        float fSin = sin(fHalfAngle);
+        Number fHalfAngle ( 0.5*rfAngle );
+        Number fSin = sin(fHalfAngle);
         w = cos(fHalfAngle);
         x = fSin*rkAxis.x;
         y = fSin*rkAxis.y;
         z = fSin*rkAxis.z;
     }
     //-----------------------------------------------------------------------
-    void ToAngleAxis (float& rfAngle, Vector3& rkAxis) 
+    void ToAngleAxis (Number& rfAngle, Vector3& rkAxis) 
     {
         // The quaternion representing the rotation is
         //   q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k)
 
-        float fSqrLength = x*x+y*y+z*z;
+        Number fSqrLength = x*x+y*y+z*z;
         if ( fSqrLength > 0.0 )
         {
             rfAngle = 2.0*acos(w);
-            float fInvLength = InvSqrt(fSqrLength);
+            Number fInvLength = InvSqrt(fSqrLength);
             rkAxis.x = x*fInvLength;
             rkAxis.y = y*fInvLength;
             rkAxis.z = z*fInvLength;
@@ -227,24 +227,24 @@ namespace Polycode {
         else
         {
             // angle is 0 (mod 2*pi), so any axis will do
-            rfAngle = float(0.0);
+            rfAngle = Number(0.0);
             rkAxis.x = 1.0;
             rkAxis.y = 0.0;
             rkAxis.z = 0.0;
         }
     }			
 			
-			void createFromAxisAngle(float x, float y, float z, float degrees);
+			void createFromAxisAngle(Number x, Number y, Number z, Number degrees);
 			Matrix4 createMatrix();
 			
 			
 			
 			Quaternion operator *(Quaternion q);
 			
-			float x;
-			float y;
-			float z;
-			float w;
+			Number x;
+			Number y;
+			Number z;
+			Number w;
 			
 		protected:
 	};

Core/Contents/Include/PolyQuaternionCurve.h

@@ -31,8 +31,8 @@ namespace Polycode {
 			QuaternionCurve(BezierCurve *wCurve, BezierCurve *xCurve, BezierCurve *yCurve, BezierCurve *zCurve);
 			~QuaternionCurve();
 		
-			Quaternion interpolate(float t, bool useShortestPath);
-			Quaternion interpolate(unsigned int fromIndex, float t, bool useShortestPath);
+			Quaternion interpolate(Number t, bool useShortestPath);
+			Quaternion interpolate(unsigned int fromIndex, Number t, bool useShortestPath);
 						
 			void generatePointsFromCurves(BezierCurve *wCurve, BezierCurve *xCurve, BezierCurve *yCurve, BezierCurve *zCurve);
 			void recalcTangents(void);

Core/Contents/Include/PolyRectangle.h

@@ -16,12 +16,12 @@ namespace Polycode {
 	class _PolyExport Rectangle {
 		public:
 			Rectangle(){x=0;y=0;w=0;h=0;}
-			Rectangle(float px, float py, float pw, float ph){x=px;y=py;w=pw;h=ph;}
-			void setRect(float x, float y, float w, float h);
+			Rectangle(Number px, Number py, Number pw, Number ph){x=px;y=py;w=pw;h=ph;}
+			void setRect(Number x, Number y, Number w, Number h);
 			
-			float x;
-			float y;
-			float w;
-			float h;
+			Number x;
+			Number y;
+			Number w;
+			Number h;
 	};
 }

Core/Contents/Include/PolyRenderer.h

@@ -32,8 +32,8 @@ namespace Polycode {
 			Vector3 position;
 			Vector3 color;
 			Vector3 dir;
-			float distance;
-			float intensity;
+			Number distance;
+			Number intensity;
 			int type;
 			Matrix4 textureMatrix;
 	};
@@ -58,52 +58,53 @@ namespace Polycode {
 		
 		virtual void renderToTexture(Texture *targetTexture) = 0;
 		virtual void renderZBufferToTexture(Texture *targetTexture) = 0;
-		virtual void setViewportSize(int w, int h, float fov=45.0f) = 0;
+		virtual void setViewportSize(int w, int h, Number fov=45.0f) = 0;
 		
 		virtual void loadIdentity() = 0;		
-		virtual void setOrthoMode(float xSize=0.0f, float ySize=0.0f) = 0;
+		virtual void setOrthoMode(Number xSize=0.0f, Number ySize=0.0f) = 0;
+		virtual void _setOrthoMode() = 0;
 		virtual void setPerspectiveMode() = 0;
 		
 		virtual void setTexture(Texture *texture) = 0;		
 		virtual void enableBackfaceCulling(bool val) = 0;
 		
-		virtual void setClearColor(float r, float g, float b) = 0;
+		virtual void setClearColor(Number r, Number g, Number b) = 0;
 		virtual void setClearColor(Color color);
 		
-		virtual void setAmbientColor(float r, float g, float b);
+		virtual void setAmbientColor(Number r, Number g, Number b);
 		
 		virtual void clearScreen() = 0;
 		
-		virtual void translate2D(float x, float y) = 0;
-		virtual void rotate2D(float angle) = 0;
+		virtual void translate2D(Number x, Number y) = 0;
+		virtual void rotate2D(Number angle) = 0;
 		virtual void scale2D(Vector2 *scale) = 0;
 		
-		virtual void setFOV(float fov) = 0;		
+		virtual void setFOV(Number fov) = 0;		
 		
-		virtual void setVertexColor(float r, float g, float b, float a) = 0;
+		virtual void setVertexColor(Number r, Number g, Number b, Number a) = 0;
 		
 		void pushDataArrayForMesh(Mesh *mesh, int arrayType);
 		
 		virtual void pushRenderDataArray(RenderDataArray *array) = 0;
 		virtual RenderDataArray *createRenderDataArrayForMesh(Mesh *mesh, int arrayType) = 0;
 		virtual RenderDataArray *createRenderDataArray(int arrayType) = 0;
-		virtual void setRenderArrayData(RenderDataArray *array, float *arrayData) = 0;
+		virtual void setRenderArrayData(RenderDataArray *array, Number *arrayData) = 0;
 		virtual void drawArrays(int drawType) = 0;
 		
 		virtual void translate3D(Vector3 *position) = 0;
-		virtual void translate3D(float x, float y, float z) = 0;
+		virtual void translate3D(Number x, Number y, Number z) = 0;
 		virtual void scale3D(Vector3 *scale) = 0;
 		
 		virtual void pushMatrix() = 0;
 		virtual void popMatrix() = 0;
 		
 		virtual void setLineSmooth(bool val) = 0;
-		virtual void setLineSize(float lineSize) = 0;
+		virtual void setLineSize(Number lineSize) = 0;
 		
 		virtual void enableLighting(bool enable) = 0;
 			
 		virtual void enableFog(bool enable) = 0;
-		virtual void setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth) = 0;
+		virtual void setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth) = 0;
 				
 		virtual void multModelviewMatrix(Matrix4 m) = 0;
 		virtual void setModelviewMatrix(Matrix4 m) = 0;
@@ -122,6 +123,7 @@ namespace Polycode {
 		int getRenderMode();
 		
 		virtual void enableDepthTest(bool val) = 0;
+		virtual void enableDepthWrite(bool val) = 0;
 		
 		void billboardMatrix();
 		void billboardMatrixWithScale(Vector3 scale);
@@ -137,15 +139,15 @@ namespace Polycode {
 		void setCameraMatrix(Matrix4 matrix);
 		void setCameraPosition(Vector3 pos);
 		
-		virtual void drawScreenQuad(float qx, float qy) = 0;
+		virtual void drawScreenQuad(Number qx, Number qy) = 0;
 		
 		int getXRes();
 		int getYRes();
 		
 		void clearLights();
-		void addLight(Vector3 position, Vector3 direction, int type, Color color, float distance, float intensity, Matrix4 *textureMatrix);
+		void addLight(Vector3 position, Vector3 direction, int type, Color color, Number distance, Number intensity, Matrix4 *textureMatrix);
 		
-		void setExposureLevel(float level);
+		void setExposureLevel(Number level);
 		
 		bool rayTriangleIntersect(Vector3 ray_origin, Vector3 ray_direction, Vector3 vert0, Vector3 vert1, Vector3 vert2, Vector3 *hitPoint);
 		
@@ -153,7 +155,7 @@ namespace Polycode {
 		
 		void addShaderModule(PolycodeShaderModule *module);
 		
-		virtual bool test2DCoordinate(float x, float y, Polygon *poly, const Matrix4 &matrix, bool billboardMode) = 0;
+		virtual bool test2DCoordinate(Number x, Number y, Polygon *poly, const Matrix4 &matrix, bool billboardMode) = 0;
 		
 		virtual Matrix4 getProjectionMatrix() = 0;
 		virtual Matrix4 getModelviewMatrix() = 0;
@@ -178,11 +180,11 @@ namespace Polycode {
 		void addShadowMap(Texture *texture);
 		vector<Texture*> getShadowMapTextures(){ return shadowMapTextures; };
 		
-		virtual Vector3 Unproject(float x, float y) = 0;
+		virtual Vector3 Unproject(Number x, Number y) = 0;
 		
 		Color	ambientColor;
 		Color	clearColor;		
-		float exposureLevel;		
+		Number exposureLevel;		
 		Vector3 cameraPosition;
 		
 		int getNumAreaLights() { return numAreaLights; }
@@ -219,7 +221,7 @@ namespace Polycode {
 		int numSpotLights;
 		
 		bool shadersEnabled;
-		float fov;
+		Number fov;
 		
 		bool lightingEnabled;
 		

Core/Contents/Include/PolyScene.h

@@ -39,7 +39,7 @@ namespace Polycode {
 		
 		void enableLighting(bool enable);
 		void enableFog(bool enable);
-		void setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth);
+		void setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth);
 
 		virtual void Update();
 		void setVirtual(bool val);
@@ -51,7 +51,7 @@ namespace Polycode {
 		int getNumEntities() { return entities.size(); }
 		SceneEntity *getEntity(int index) { return entities[index]; }
 		
-		SceneEntity *getEntityAtCursor(float x, float y);
+		SceneEntity *getEntityAtCursor(Number x, Number y);
 		
 	protected:
 		
@@ -65,9 +65,9 @@ namespace Polycode {
 		bool fogEnabled;
 		int fogMode;
 		Color fogColor;
-		float fogDensity;
-		float fogStartDepth;
-		float fogEndDepth;
+		Number fogDensity;
+		Number fogStartDepth;
+		Number fogEndDepth;
 		
 	};
 }

Core/Contents/Include/PolySceneEntity.h

@@ -29,7 +29,7 @@ namespace Polycode {
 			SceneEntity();
 			virtual ~SceneEntity();
 		
-			virtual bool testMouseCollision(float x, float y) { return false;}
+			virtual bool testMouseCollision(Number x, Number y) { return false;}
 
 			void ok() { Logger::log("ok!!1\n"); }
 			

Core/Contents/Include/PolySceneLabel.h

@@ -28,10 +28,10 @@ namespace Polycode {
 	class _PolyExport SceneLabel : public SceneEntity {
 		public:
 			
-			SceneLabel(String fontName, String text, int size, float scale, int amode);
+			SceneLabel(String fontName, String text, int size, Number scale, int amode);
 			~SceneLabel();			
 		
-			bool testMouseCollision(float x, float y);
+			bool testMouseCollision(Number x, Number y);
 		
 			void setText(String newText);
 			Label *getLabel();
@@ -42,7 +42,7 @@ namespace Polycode {
 			Mesh *mesh;
 			Texture *texture;		
 		
-			float scale;
+			Number scale;
 			Label *label;
 	};
 }

Core/Contents/Include/PolySceneLight.h

@@ -24,11 +24,11 @@ namespace Polycode {
 	class Camera;
 	class _PolyExport SceneLight : public SceneEntity {
 		public:
-			SceneLight(int type, float intensity, float distance, Scene *parentScene);
+			SceneLight(int type, Number intensity, Number distance, Scene *parentScene);
 			virtual ~SceneLight();
 		
-			float getIntensity();
-			float getDistance();
+			Number getIntensity();
+			Number getDistance();
 			int getType();
 			
 			void renderDepthMap(Scene *scene);
@@ -43,9 +43,9 @@ namespace Polycode {
 			Texture *getZBufferTexture();
 			Color lightColor;
 		
-			void setLightColor(float r, float g, float b) { lightColor.r = r; lightColor.g = g; lightColor.b = b; }
-			void enableShadows(bool val, float resolution=256);
-			void setShadowMapFOV(float fov);
+			void setLightColor(Number r, Number g, Number b) { lightColor.r = r; lightColor.g = g; lightColor.b = b; }
+			void enableShadows(bool val, Number resolution=256);
+			void setShadowMapFOV(Number fov);
 		
 			bool areShadowsEnabled();
 		
@@ -54,7 +54,7 @@ namespace Polycode {
 		private:
 		
 			int type;
-			float intensity;
+			Number intensity;
 			
 			Camera *spotCamera;
 			Texture *zBufferTexture;
@@ -63,11 +63,11 @@ namespace Polycode {
 			
 			Matrix4 lightViewMatrix;
 		
-			float shadowMapRes;
-			float shadowMapFOV;	
+			Number shadowMapRes;
+			Number shadowMapFOV;	
 			bool shadowsEnabled;
 		
-			float distance;
+			Number distance;
 			Mesh *lightMesh;
 	};
 }

Core/Contents/Include/PolySceneLine.h

@@ -14,18 +14,22 @@
 #include "PolyGlobals.h"
 #include "PolySceneEntity.h"
 #include "PolyCoreServices.h"
+#include "PolyMesh.h"
 
 namespace Polycode {
 	class _PolyExport SceneLine : public SceneEntity {
 		public:
-			SceneLine(Vector3 p1, Vector3 p2);
+			SceneLine(SceneEntity *ent1, SceneEntity *ent2);
 			~SceneLine();
 			
 			void Render();
 			
-		private:
-			Vertex v1;
-			Vertex v2;
+		private:		
+		
+			Mesh *mesh;
+		
+			SceneEntity *ent1;
+			SceneEntity *ent2;
 	};
 
 }

Core/Contents/Include/PolySceneMesh.h

@@ -40,7 +40,7 @@ namespace Polycode {
 			Mesh *getMesh();
 			Texture *getTexture();
 			Material *getMaterial();
-			void loadTexture(String fileName);
+			void loadTexture(String fileName, bool clamp=true);
 			void loadSkeleton(String fileName);
 			void setTexture(Texture *texture);
 			void setMaterial(Material *material);

Core/Contents/Include/PolyScenePrimitive.h

@@ -23,7 +23,7 @@ namespace Polycode {
 	class _PolyExport ScenePrimitive : public SceneMesh {
 		public:
 		
-			ScenePrimitive(int type, float v1=1.0f, float v2=1.0f, float v3=1.0f);
+			ScenePrimitive(int type, Number v1=1.0f, Number v2=1.0f, Number v3=1.0f);
 			virtual ~ScenePrimitive();
 
 			static const int TYPE_BOX = 0;		

Core/Contents/Include/PolyScreen.h

@@ -31,16 +31,16 @@ namespace Polycode {
 		ScreenEntity* addChild(ScreenEntity *newEntity);
 		ScreenEntity* removeChild(ScreenEntity *entityToRemove);
 		
-		void setScreenOffset(float x, float y);
+		void setScreenOffset(Number x, Number y);
 		Vector2 getScreenOffset();
 		
 		virtual void Shutdown();
 		virtual void Update();
-		ScreenEntity *getEntityAt(float x, float y);
+		ScreenEntity *getEntityAt(Number x, Number y);
 		void Render();
 		void setRenderer(Renderer *renderer);
 		
-		void setNormalizedCoordinates(bool newVal, float yCoordinateSize = 1.0f);
+		void setNormalizedCoordinates(bool newVal, Number yCoordinateSize = 1.0f);
 		void setScreenShader(String shaderName);
 		
 		void handleEvent(Event *event);
@@ -54,7 +54,7 @@ namespace Polycode {
 		void drawFilter();
 		
 		bool usesNormalizedCoordinates() { return useNormalizedCoordinates; }
-		float getYCoordinateSize() { return yCoordinateSize; }
+		Number getYCoordinateSize() { return yCoordinateSize; }
 		
 		bool Lua_EntitiesEqual(ScreenEntity *ent1, ScreenEntity *ent2) { return ent1 == ent2; }
 		
@@ -65,7 +65,7 @@ namespace Polycode {
 	protected:
 		
 		bool useNormalizedCoordinates;
-		float yCoordinateSize;		
+		Number yCoordinateSize;		
 		
 		ScreenEntity *rootEntity;
 		

Core/Contents/Include/PolyScreenCurve.h

@@ -27,7 +27,7 @@ namespace Polycode {
 			
 		protected:
 		
-			float numVertices;
+			Number numVertices;
 			BezierCurve *curve;
 	};
 }

Core/Contents/Include/PolyScreenEntity.h

@@ -31,22 +31,22 @@ class _PolyExport ScreenEntity : public Entity, public EventDispatcher {
 		ScreenEntity();
 		~ScreenEntity();
 		
-		void setPosition(float x, float y);
-		void setScale(float x, float y);
-		void setRotation(float roatation);
-		float getRotation();
+		void setPosition(Number x, Number y);
+		void setScale(Number x, Number y);
+		void setRotation(Number roatation);
+		Number getRotation();
 			
-		bool _onMouseDown(float x, float y, int timestamp);
-		bool _onMouseUp(float x, float y, int timestamp);
-		void _onMouseMove(float x, float y, int timestamp);
-		void _onMouseWheelUp(float x, float y, int timestamp);
-		void _onMouseWheelDown(float x, float y, int timestamp);
+		bool _onMouseDown(Number x, Number y, int mouseButton, int timestamp);
+		bool _onMouseUp(Number x, Number y, int mouseButton, int timestamp);
+		void _onMouseMove(Number x, Number y, int timestamp);
+		void _onMouseWheelUp(Number x, Number y, int timestamp);
+		void _onMouseWheelDown(Number x, Number y, int timestamp);
 	
-		virtual void onMouseDown(float x, float y){}
-		virtual void onMouseUp(float x, float y){}
-		virtual	void onMouseMove(float x, float y){}
-		virtual void onMouseWheelUp(float x, float y) {}
-		virtual void onMouseWheelDown(float x, float y) {}
+		virtual void onMouseDown(Number x, Number y){}
+		virtual void onMouseUp(Number x, Number y){}
+		virtual	void onMouseMove(Number x, Number y){}
+		virtual void onMouseWheelUp(Number x, Number y) {}
+		virtual void onMouseWheelDown(Number x, Number y) {}
 	
 		void _onKeyDown(TAUKey key, wchar_t charCode);	
 		void _onKeyUp(TAUKey key, wchar_t charCode);	
@@ -54,21 +54,21 @@ class _PolyExport ScreenEntity : public Entity, public EventDispatcher {
 		virtual void onKeyDown(TAUKey key, wchar_t charCode){}
 		virtual void onKeyUp(TAUKey key, wchar_t charCode){}
 		
-		bool hitTest(float x, float y);		
+		bool hitTest(Number x, Number y);		
 	
 		Matrix4 buildPositionMatrix();
 		void adjustMatrixForChildren();
 
-		float getWidth();
-		float getHeight();
+		Number getWidth();
+		Number getHeight();
 	
-		void setWidth(float w) { width = w; hitwidth = w; }
-		void setHeight(float h) { height = h; hitheight = h; }
+		void setWidth(Number w) { width = w; hitwidth = w; }
+		void setHeight(Number h) { height = h; hitheight = h; }
 	
 		virtual void onGainFocus(){}
 		virtual void onLoseFocus(){}		
 		
-		void startDrag(float xOffset, float yOffset);
+		void startDrag(Number xOffset, Number yOffset);
 		void stopDrag();
 				
 		void setBlendingMode(int newBlendingMode);
@@ -100,18 +100,18 @@ class _PolyExport ScreenEntity : public Entity, public EventDispatcher {
 		bool focusChildren;
 		
 		bool isDragged;
-		float dragOffsetX;
-		float dragOffsetY;
+		Number dragOffsetX;
+		Number dragOffsetY;
 		
 		bool mouseOver;
-		float width;
-		float height;
+		Number width;
+		Number height;
 
-		float hitwidth;
-		float hitheight;
+		Number hitwidth;
+		Number hitheight;
 		
-		float xmouse;
-		float ymouse;
+		Number xmouse;
+		Number ymouse;
 		
 		int positionMode;		
 		Rectangle *dragLimits;

Core/Contents/Include/PolyScreenImage.h

@@ -31,14 +31,14 @@ namespace Polycode {
 		ScreenImage(Image *image);		
 		~ScreenImage();
 		
-		void setImageCoordinates(float x, float y, float width, float height);
-		float getImageWidth();
-		float getImageHeight();
+		void setImageCoordinates(Number x, Number y, Number width, Number height);
+		Number getImageWidth();
+		Number getImageHeight();
 		
 		private:
 
-		float imageWidth;
-		float imageHeight;
+		Number imageWidth;
+		Number imageHeight;
 		
 	};
 

Core/Contents/Include/PolyScreenLabel.h

@@ -33,7 +33,7 @@ namespace Polycode {
 			ScreenLabel(String fontName, String text, int size, int amode);
 			~ScreenLabel();		
 		
-			void addDropShadow(Color color, float size, float offsetX, float offsetY);
+			void addDropShadow(Color color, Number size, Number offsetX, Number offsetY);
 			void setText(String newText);
 			String getText();
 		

Core/Contents/Include/PolyScreenLine.h

@@ -30,11 +30,11 @@ namespace Polycode {
 
 			void Update();
 			void Render();
-			void setLineWidth(float width);
+			void setLineWidth(Number width);
 			
 		protected:
 		
-			float lineWidth;
+			Number lineWidth;
 			
 			Vertex startVertex;
 			Vertex endVertex;

Core/Contents/Include/PolyScreenShape.h

@@ -26,19 +26,19 @@ namespace Polycode {
 	class _PolyExport ScreenShape : public ScreenMesh {
 		public:
 			
-			ScreenShape(int shapeType, float option1=0, float option2=0, float option3=0, float option4=0);
+			ScreenShape(int shapeType, Number option1=0, Number option2=0, Number option3=0, Number option4=0);
 			~ScreenShape();
 			void Render();
 					
-			void setStrokeColor(float r, float g, float b, float a);
-			void setStrokeWidth(float width);
+			void setStrokeColor(Number r, Number g, Number b, Number a);
+			void setStrokeWidth(Number width);
 			
-			void setGradient(float r1, float g1, float b1, float a1, float r2, float g2, float b2, float a2);
+			void setGradient(Number r1, Number g1, Number b1, Number a1, Number r2, Number g2, Number b2, Number a2);
 			void clearGradient();
 		
-			void setShapeSize(float newWidth, float newHeight);
+			void setShapeSize(Number newWidth, Number newHeight);
 		
-			void addShapePoint(float x, float y);
+			void addShapePoint(Number x, Number y);
 			
 			static const int SHAPE_RECT = 1;
 			static const int SHAPE_CIRCLE = 2;
@@ -51,13 +51,13 @@ namespace Polycode {
 			
 		protected:
 		
-			float option1;
-			float option2;
-			float option3;
-			float option4;
+			Number option1;
+			Number option2;
+			Number option3;
+			Number option4;
 									
 			Polygon *customShapePoly;
-			float strokeWidth;
+			Number strokeWidth;
 			int shapeType;
 			
 	};

Core/Contents/Include/PolyScreenSprite.h

@@ -18,7 +18,7 @@ namespace Polycode {
 
 class SpriteAnimation {
 	public:
-		float speed;
+		Number speed;
 		String name;
 		int numFrames;
 	
@@ -28,23 +28,23 @@ class SpriteAnimation {
 class ScreenSprite : public ScreenShape 
 {
 	public:
-		ScreenSprite(String fileName, float spriteWidth, float spriteHeight);
+		ScreenSprite(String fileName, Number spriteWidth, Number spriteHeight);
 		~ScreenSprite();
 		
-		void addAnimation(String name, String frames, float speed);
+		void addAnimation(String name, String frames, Number speed);
 		void playAnimation(String name, int startFrame, bool once);
 		void Update();
 		
 	private:
 	
-		float spriteWidth;
-		float spriteHeight;
+		Number spriteWidth;
+		Number spriteHeight;
 			
 		bool playingOnce;
-		float lastTick;
+		Number lastTick;
 		
-		float spriteUVWidth;
-		float spriteUVHeight;
+		Number spriteUVWidth;
+		Number spriteUVHeight;
 		int currentFrame;
 		SpriteAnimation *currentAnimation;
 		

Core/Contents/Include/PolyShader.h

@@ -41,8 +41,8 @@ namespace Polycode {
 	class _PolyExport ShaderRenderTarget {
 		public:
 			String id;
-			float width;
-			float height;
+			Number width;
+			Number height;
 			int sizeMode;
 			bool hasSize;
 			Texture *texture;
@@ -61,8 +61,8 @@ namespace Polycode {
 			String name;
 			int mode;
 			Texture *texture;
-			float width;
-			float height;			
+			Number width;
+			Number height;			
 			static const int MODE_IN= 0;
 			static const int MODE_OUT = 1;
 	} RenderTargetBinding;

Core/Contents/Include/PolySkeleton.h

@@ -14,21 +14,23 @@
 #include "PolyBone.h"
 #include <string>
 #include <vector>
+#include "PolyBezierCurve.h"
+#include "PolyTween.h"
 
 using std::string;
 using std::vector;
 
 namespace Polycode {
-
+	
 	class _PolyExport BoneTrack {
 		public:
-			BoneTrack(Bone *bone);
+			BoneTrack(Bone *bone, Number length);
 			~BoneTrack();
 			void Play();
 			void Stop();
 			void Update();
 		
-			void setSpeed(float speed);
+			void setSpeed(Number speed);
 			
 			BezierCurve *scaleX;
 			BezierCurve *scaleY;
@@ -45,6 +47,11 @@ namespace Polycode {
 			Vector3 LocYVec;
 			Vector3 LocZVec;						
 
+			Vector3 ScaleXVec;
+			Vector3 ScaleYVec;
+			Vector3 ScaleZVec;						
+		
+		
 			Quaternion boneQuat;
 			QuaternionTween *quatTween;
 			
@@ -52,9 +59,12 @@ namespace Polycode {
 			Vector3 QuatXVec;
 			Vector3 QuatYVec;			
 			Vector3 QuatZVec;		
+		
 			
 		protected:
-			
+		
+			Number length;
+		
 			bool initialized;
 		
 			Bone *targetBone;
@@ -64,7 +74,7 @@ namespace Polycode {
 
 	class _PolyExport SkeletonAnimation {
 		public:
-			SkeletonAnimation(String name, float duration);
+			SkeletonAnimation(String name, Number duration);
 			~SkeletonAnimation();			
 			void addBoneTrack(BoneTrack *boneTrack);
 			String getName();
@@ -72,28 +82,31 @@ namespace Polycode {
 			void Stop();
 			void Update();
 		
-			void setSpeed(float speed);
+			void setSpeed(Number speed);
 			
 		private:
 			
 			String name;
-			float duration;
+			Number duration;
 			vector<BoneTrack*> boneTracks;
 	};
 
 	class _PolyExport Skeleton : public SceneEntity {
 		public:
 			Skeleton(String fileName);
+			Skeleton();
 			void loadSkeleton(String fileName);
 			~Skeleton();
 		
 			void playAnimation(String animName);
+			void playAnimationByIndex(int index);		
+			void addAnimation(String name, String fileName);
 			SkeletonAnimation *getAnimation(String name);
 			void Update();
 			
 			Bone *getBoneByName(String name);
 			void bonesVisible(bool val);
-			void enableBoneLabels(Font *font, float size, float scale);
+			void enableBoneLabels(String labelFont, Number size, Number scale, Color labelColor);
 					
 			int getNumBones();
 			Bone *getBone(int index);
@@ -101,6 +114,9 @@ namespace Polycode {
 			SkeletonAnimation *getCurrentAnimation() { return currentAnimation; }
 		
 		private:
+		
+			SceneEntity *bonesEntity;
+		
 			SkeletonAnimation *currentAnimation;
 			vector<Bone*> bones;
 			vector<SkeletonAnimation*> animations;

Core/Contents/Include/PolyString.h

@@ -57,7 +57,7 @@ namespace Polycode {
 			vector<String> split(const String &delims);
 			String replace(const String &what, const String &withWhat);
 			
-			static String floatToString(float value);
+			static String NumberToString(Number value);
 		
 			const char *c_str();
 			const wchar_t *wc_str();

Core/Contents/Include/PolySubstanceView.h

@@ -30,9 +30,14 @@ using namespace Polycode;
 	NSCursor *currentCursor;
 	bool contextReady;
 	
+	int mouseX;
+	int mouseY;
+	
 }
 
 @property BOOL viewReady;
+@property int mouseX;
+@property int mouseY;
 
 - (void) setCurrentCursor: (NSCursor*) newCursor;
 

Core/Contents/Include/PolyTexture.h

@@ -23,15 +23,15 @@ namespace Polycode {
 			Texture(Image *image);
 			virtual ~Texture();
 
-			float scrollSpeedX;
-			float scrollSpeedY;
+			Number scrollSpeedX;
+			Number scrollSpeedY;
 			
 			virtual void setTextureData(char *data) = 0;
 
 			virtual void recreateFromImageData() = 0;
 
-			float getScrollOffsetX();
-			float getScrollOffsetY();
+			Number getScrollOffsetX();
+			Number getScrollOffsetY();
 			
 			void setImageData(Image *data);
 		
@@ -55,7 +55,7 @@ namespace Polycode {
 			int height;
 			String resourcePath;
 			char *textureData;
-			float scrollOffsetX;
-			float scrollOffsetY;
+			Number scrollOffsetX;
+			Number scrollOffsetY;
 	};
 }

Core/Contents/Include/PolyTimer.h

@@ -29,7 +29,7 @@ namespace Polycode {
 		void Update(unsigned int ticks);
 		void Reset();
 		bool hasElapsed();
-		float getElapsedf();		
+		Number getElapsedf();		
 
 		static const int EVENT_TRIGGER = 0;
 		

Core/Contents/Include/PolyTween.h

@@ -23,11 +23,11 @@ namespace Polycode {
 	
 	class _PolyExport Tween : public EventDispatcher {
 	public:
-		Tween(float *target, int easeType, float startVal, float endVal, float time, bool repeat=false);
+		Tween(Number *target, int easeType, Number startVal, Number endVal, Number time, bool repeat=false);
 		~Tween();
 		
 		void handleEvent(Event *event);
-		float interpolateTween();
+		Number interpolateTween();
 		virtual void updateCustomTween() {}
 		void doOnComplete();
 		
@@ -64,7 +64,7 @@ namespace Polycode {
 		bool isComplete();
 		bool repeat;
 		
-		void setSpeed(float speed);
+		void setSpeed(Number speed);
 		
 
 	protected:
@@ -72,25 +72,25 @@ namespace Polycode {
 		
 		int easeType;
 		bool complete;
-		float endVal;
-		float cVal;
-		float startVal;
-		float actEndTime;
-		float endTime;
-		float *targetVal;
-		float localTargetVal;
-		float tweenTime;
+		Number endVal;
+		Number cVal;
+		Number startVal;
+		Number actEndTime;
+		Number endTime;
+		Number *targetVal;
+		Number localTargetVal;
+		Number tweenTime;
 		Timer *tweenTimer;
 	};
 	
 	class _PolyExport BezierPathTween : public Tween {
 		public:
-			BezierPathTween(Vector3 *target, BezierCurve *curve, int easeType, float time, bool repeat=false);
+			BezierPathTween(Vector3 *target, BezierCurve *curve, int easeType, Number time, bool repeat=false);
 			~BezierPathTween();
 			void updateCustomTween();
 
 		protected:
-			float pathValue;
+			Number pathValue;
 			Tween *pathTween;
 			BezierCurve *curve;
 			Vector3 *target;
@@ -99,11 +99,11 @@ namespace Polycode {
 	class _PolyExport QuaternionTween : public Tween {
 		public:
 			QuaternionTween(Quaternion *target, BezierCurve *wCurve, BezierCurve *xCurve, BezierCurve *yCurve,
-							BezierCurve *zCurve, int easeType, float time, bool repeat=false);
+							BezierCurve *zCurve, int easeType, Number time, bool repeat=false);
 			~QuaternionTween();
 			void updateCustomTween();
 		private:
-			float pathValue;
+			Number pathValue;
 			Tween *pathTween;
 			QuaternionCurve	*quatCurve;
 			Quaternion *target;			

Core/Contents/Include/PolyVector2.h

@@ -19,8 +19,8 @@ namespace Polycode {
 		public:
 		
 			Vector2();
-			Vector2(float x, float y);
-			~Vector2();
+			Vector2(Number x, Number y);
+			virtual ~Vector2();
 		
 			inline bool operator == ( const Vector2& v2)  {
 				return (v2.x == x && v2.y == y);
@@ -30,8 +30,8 @@ namespace Polycode {
 				return (v2.x != x || v2.y != y);
 			}				
 		
-			float x;
-			float y;			
+			Number x;
+			Number y;			
 			
 		private:
 

Core/Contents/Include/PolyVector3.h

@@ -24,27 +24,27 @@ namespace Polycode {
 		public:
 		
 			Vector3();
-			Vector3(float x,float y,float z);
-			~Vector3();
+			Vector3(Number x,Number y,Number z);
+			virtual ~Vector3();
 
-			void set(float x, float y, float z);
+			void set(Number x, Number y, Number z);
 
 			inline Vector3 operator - ( const Vector3& v2 ) const {
 				return Vector3(x - v2.x, y - v2.y, z - v2.z);
 			}
 
-			inline float distance(const Vector3& rhs) const {
+			inline Number distance(const Vector3& rhs) const {
 				return (*this - rhs).length();
 			}
 
-			inline Vector3& operator * (const float val) {
+			inline Vector3& operator * (const Number val) {
 				x *= val;
 				y *= val;
 				z *= val;
 				return *this;				
 			}
 
-			inline Vector3& operator / (const float val) {
+			inline Vector3& operator / (const Number val) {
 				assert( val != 0.0 );
 				x /= val;
 				y /= val;
@@ -75,13 +75,13 @@ namespace Polycode {
 	
 			inline Vector3 operator + ( const Vector3& v2 ) const {
 				return Vector3(x + v2.x, y + v2.y, z + v2.z);
-			}
+			}		
 
-			inline float length () const {
+			inline Number length () const {
 				return sqrtf( x * x + y * y + z * z );
 			}
 			
-			inline float dot(Vector3 &u) {
+			inline Number dot(Vector3 &u) {
 				return x * u.x + y * u.y + z * u.z;
 			}
 
@@ -94,9 +94,9 @@ namespace Polycode {
 
 			void Normalize();
 		
-			float x;
-			float y;
-			float z;			
+			Number x;
+			Number y;
+			Number z;			
 			
 		private:
 

Core/Contents/Include/PolyVertex.h

@@ -27,7 +27,7 @@ namespace Polycode {
 				bone = NULL;
 			}
 			unsigned int boneID;
-			float weight;
+			Number weight;
 			Bone *bone;
 	};
 
@@ -35,22 +35,23 @@ namespace Polycode {
 		public:
 		
 			Vertex();
-			Vertex(float pos_x, float pos_y, float pos_z, float nor_x, float nor_y, float nor_z);
-			Vertex(float pos_x, float pos_y, float pos_z, float nor_x, float nor_y, float nor_z, float u, float v);		
-			Vertex(float x, float y, float z);
-			Vertex(float x, float y, float z, float u, float v);
-			~Vertex();
+			Vertex(Number pos_x, Number pos_y, Number pos_z, Number nor_x, Number nor_y, Number nor_z);
+			Vertex(Number pos_x, Number pos_y, Number pos_z, Number nor_x, Number nor_y, Number nor_z, Number u, Number v);		
+			Vertex(Number x, Number y, Number z);
+			Vertex(Number x, Number y, Number z, Number u, Number v);
+			virtual ~Vertex();
 			
-			void addBoneAssignment(unsigned int boneID, float boneWeight);
+			void addBoneAssignment(unsigned int boneID, Number boneWeight);
 			int getNumBoneAssignments();
 			BoneAssignment *getBoneAssignment(unsigned int index);
 			
 			void normalizeWeights();
 			
 			Vector2 *getTexCoord();
-			void setTexCoord(float u, float v);
-			void setNormal(float x, float y, float z);
+			void setTexCoord(Number u, Number v);
+			void setNormal(Number x, Number y, Number z);
 
+			Vector3 restNormal;
 			Vector3 *normal;
 			Vector3 restPosition;
 

Core/Contents/Include/tinyxml.h

@@ -994,11 +994,11 @@ public:
 	/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
 	int QueryDoubleAttribute( const char* name, double* _value ) const;
 	/// QueryFloatAttribute examines the attribute - see QueryIntAttribute().
-	int QueryFloatAttribute( const char* name, float* _value ) const {
+	int QueryFloatAttribute( const char* name, Number* _value ) const {
 		double d;
 		int result = QueryDoubleAttribute( name, &d );
 		if ( result == TIXML_SUCCESS ) {
-			*_value = (float)d;
+			*_value = (Number)d;
 		}
 		return result;
 	}

Core/Contents/Source/PolyBezierCurve.cpp

@@ -13,7 +13,7 @@
 using namespace Polycode;
 
 
-BezierPoint::BezierPoint(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z) {
+BezierPoint::BezierPoint(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z) {
 	p1.x = p1x;
 	p1.y = p1y;
 	p1.z = p1z;		
@@ -37,7 +37,7 @@ BezierCurve::~BezierCurve() {
 
 }
 
-void BezierCurve::addControlPoint(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z) {
+void BezierCurve::addControlPoint(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z) {
 	BezierPoint* newPoint = new BezierPoint(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z);
 	controlPoints.push_back(newPoint);
 	distances.push_back(0);
@@ -45,19 +45,19 @@ void BezierCurve::addControlPoint(float p1x, float p1y, float p1z, float p2x, fl
 	buffersDirty = true;	
 }
 
-void BezierCurve::addControlPoint3dWithHandles(float p1x, float p1y, float p1z, float p2x, float p2y, float p2z, float p3x, float p3y, float p3z) {
+void BezierCurve::addControlPoint3dWithHandles(Number p1x, Number p1y, Number p1z, Number p2x, Number p2y, Number p2z, Number p3x, Number p3y, Number p3z) {
 	addControlPoint(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z);
 }
 
-void BezierCurve::addControlPoint3d(float x, float y, float z) {
+void BezierCurve::addControlPoint3d(Number x, Number y, Number z) {
 	addControlPoint(x, y, z, x, y, z, x, y, z);
 }
 
-void BezierCurve::addControlPoint2dWithHandles(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y) {
+void BezierCurve::addControlPoint2dWithHandles(Number p1x, Number p1y, Number p2x, Number p2y, Number p3x, Number p3y) {
 	addControlPoint(p1x, p1y, 0, p2x, p2y, 0, p3x, p3y, 0);
 }
 
-void BezierCurve::addControlPoint2d(float x, float y) {
+void BezierCurve::addControlPoint2d(Number x, Number y) {
 	addControlPoint(x, y, 0, x, y, 0, x, y, 0);
 }
 
@@ -66,15 +66,15 @@ void BezierCurve::recalculateDistances() {
 	if(controlPoints.size() < 2)
 		return;
 		
-	float dist, lastDist = 0;
+	Number dist, lastDist = 0;
 	distances[0] = 0;
-	float totalDistance = 0;
+	Number totalDistance = 0;
 		
 	Vector3 point, lastPoint;
 	for(int i=0; i < controlPoints.size()-1; i++) {
 		lastPoint = getPointBetween(0, controlPoints[i], controlPoints[i+1]);
 		dist = 0;
-		for(float a=0.0f; a < 1.0f; a += 0.01) {
+		for(Number a=0.0f; a < 1.0f; a += 0.01) {
 			point = getPointBetween(a, controlPoints[i], controlPoints[i+1]);
 			dist += point.distance(lastPoint);
 			lastPoint = point;
@@ -90,9 +90,9 @@ void BezierCurve::recalculateDistances() {
 	}
 }
 
-Vector3 BezierCurve::getPointBetween(float a, BezierPoint *bp1, BezierPoint *bp2) {
+Vector3 BezierCurve::getPointBetween(Number a, BezierPoint *bp1, BezierPoint *bp2) {
 	Vector3 retVector;
-	float b = 1.0f - a;
+	Number b = 1.0f - a;
 	
 	retVector.x = bp1->p2.x*a*a*a + bp1->p3.x*3*a*a*b + bp2->p1.x*3*a*b*b + bp2->p2.x*b*b*b;
 	retVector.y = bp1->p2.y*a*a*a + bp1->p3.y*3*a*a*b + bp2->p1.y*3*a*b*b + bp2->p2.y*b*b*b;
@@ -109,14 +109,14 @@ unsigned int BezierCurve::getNumControlPoints() {
 	return controlPoints.size();
 }
 
-float BezierCurve::getHeightAt(float a) {
+Number BezierCurve::getHeightAt(Number a) {
 	if( a< 0) a = 0;
 	if(a > 1) a = 1;
 	
 	if (buffersDirty) 
 		rebuildBuffers();
 	
-	int index = ((float)(BUFFER_CACHE_PRECISION)) * a;	
+	int index = ((Number)(BUFFER_CACHE_PRECISION)) * a;	
 	return heightBuffer[index];
 	
 //	return getPointAt(a).y;
@@ -124,12 +124,12 @@ float BezierCurve::getHeightAt(float a) {
 
 void BezierCurve::rebuildBuffers() {
 	for(int i=0; i < BUFFER_CACHE_PRECISION; i++) {
-		heightBuffer[i]	= getPointAt(((float)i)/((float)BUFFER_CACHE_PRECISION)).y;
+		heightBuffer[i]	= getPointAt(((Number)i)/((Number)BUFFER_CACHE_PRECISION)).y;
 	}
 	buffersDirty = false;
 }
 
-Vector3 BezierCurve::getPointAt(float a) {
+Vector3 BezierCurve::getPointAt(Number a) {
 	if(a < 0)
 		a = 0;
 	if(a > 1)

Core/Contents/Source/PolyBone.cpp

@@ -13,15 +13,15 @@ using namespace Polycode;
 
 Bone::Bone(String boneName) : SceneEntity() {
 	this->boneName = boneName;
-
-	boneMesh = new Mesh(Mesh::QUAD_MESH);
-	boneMesh->createBox(0.1,0.1,0.1);
-	bBoxRadius = boneMesh->getRadius();
-	bBox = boneMesh->calculateBBox();
-//	color.setColor(1.0f, 0.0f, 0.0f, 1.0f);
-	this->setDepthWrite(false);
+//	boneMesh = new ScenePrimitive(ScenePrimitive::TYPE_BOX, 0.1, 0.1, 0.1);
+	this->depthTest = false;
 	parentBone = NULL;
 	boneMatrix.init();
+//	addChild(boneMesh);
+	
+	boneMesh = new Mesh(Mesh::QUAD_MESH);
+	boneMesh->createBox(0.2,0.2,0.2);
+	
 }
 
 
@@ -61,7 +61,7 @@ Matrix4 Bone::getBoneMatrix() {
 }
 
 Matrix4 Bone::getFinalMatrix() {
-	Matrix4 final = boneMatrix * restMatrix;
+	Matrix4 final = boneMatrix;
 
 	if(parentBone) {
 		final = final * parentBone->getFinalMatrix();
@@ -74,6 +74,10 @@ void Bone::setBoneMatrix(Matrix4 matrix) {
 	boneMatrix = matrix;
 }
 
+void Bone::setBaseMatrix(Matrix4 matrix) {
+	baseMatrix = matrix;
+}
+
 Matrix4 Bone::getRestMatrix() {
 	return restMatrix;
 }
@@ -88,6 +92,15 @@ Matrix4 Bone::getParentRestMatrix() {
 	}
 }
 
+Matrix4 Bone::getFullBaseMatrix() {
+	if(parentBone)
+		return baseMatrix * parentBone->getFullBaseMatrix();
+	else {
+		return baseMatrix;
+	}
+	
+}
+
 Matrix4 Bone::getFullRestMatrix() {
 	if(parentBone)
 		return restMatrix * parentBone->getFullRestMatrix();
@@ -104,19 +117,21 @@ String Bone::getName() {
 	return boneName;
 }
 
-void Bone::enableBoneLabel(Font *font, float size, float scale) {
-//	SceneLabel *label = new SceneLabel("", boneName, size, scale, Label::ANTIALIAS_FULL);
-	SceneLabel *label = new SceneLabel("", L"FIX ME", size, scale, Label::ANTIALIAS_FULL);	
+void Bone::enableBoneLabel(String fontLabel, Number size, Number scale, Color labelColor) {
+	SceneLabel *label = new SceneLabel(fontLabel, boneName, size, scale, Label::ANTIALIAS_FULL);
+	label->setColor(labelColor);
 	label->billboardMode = true;
-	label->setDepthWrite(false);
+	label->depthTest = false;
 	addEntity(label);
 }
 
 void Bone::Render() {
+
 	CoreServices::getInstance()->getRenderer()->setTexture(NULL);	
 //	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::COLOR_DATA_ARRAY);
-//	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::VERTEX_DATA_ARRAY);
-//	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::TEXCOORD_DATA_ARRAY);	
-//	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::NORMAL_DATA_ARRAY);		
-//	renderer->drawArrays(boneMesh->getMeshType());	
+	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::VERTEX_DATA_ARRAY);
+	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::TEXCOORD_DATA_ARRAY);	
+	renderer->pushDataArrayForMesh(boneMesh, RenderDataArray::NORMAL_DATA_ARRAY);		
+	renderer->drawArrays(boneMesh->getMeshType());	
+
 }

Core/Contents/Source/PolyCamera.cpp

@@ -24,26 +24,26 @@ Camera::~Camera() {
 
 }
 
-void Camera::setExposureLevel(float level) {
+void Camera::setExposureLevel(Number level) {
 	exposureLevel = level;
 }
 
-float Camera::getExposureLevel() {
+Number Camera::getExposureLevel() {
 	return exposureLevel;
 }
 
 
-void Camera::setFOV(float fov) {
+void Camera::setFOV(Number fov) {
 	this->fov = fov;
 	fovSet = true;
 }
 
-float Camera::getFOV() {
+Number Camera::getFOV() {
 	return fov;
 }
 
 
-bool Camera::isSphereInFrustrum(Vector3 pos, float fRadius) {
+bool Camera::isSphereInFrustrum(Vector3 pos, Number fRadius) {
     for( int i = 0; i < 6; ++i )
     {
         if( frustumPlanes[i][0] * pos.x +
@@ -69,7 +69,7 @@ void Camera::buildFrustrumPlanes() {
 	Matrix4 p; 
 	Matrix4 mv;
 	Matrix4 mvp;
-	float t;
+	Number t;
 
 	p = CoreServices::getInstance()->getRenderer()->getProjectionMatrix();
     mv = CoreServices::getInstance()->getRenderer()->getModelviewMatrix();
@@ -109,7 +109,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[0][2] = mvp.ml[11] - mvp.ml[ 8];
     frustumPlanes[0][3] = mvp.ml[15] - mvp.ml[12];
 
-    t = (float) sqrt( frustumPlanes[0][0] * frustumPlanes[0][0] + 
+    t = (Number) sqrt( frustumPlanes[0][0] * frustumPlanes[0][0] + 
                       frustumPlanes[0][1] * frustumPlanes[0][1] + 
                       frustumPlanes[0][2] * frustumPlanes[0][2] );
 
@@ -127,7 +127,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[1][2] = mvp.ml[11] + mvp.ml[ 8];
     frustumPlanes[1][3] = mvp.ml[15] + mvp.ml[12];
 
-    t = (float) sqrt( frustumPlanes[1][0] * frustumPlanes[1][0] + 
+    t = (Number) sqrt( frustumPlanes[1][0] * frustumPlanes[1][0] + 
                       frustumPlanes[1][1] * frustumPlanes[1][1] + 
                       frustumPlanes[1][2] * frustumPlanes[1][2] );
 
@@ -145,7 +145,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[2][2] = mvp.ml[11] + mvp.ml[ 9];
     frustumPlanes[2][3] = mvp.ml[15] + mvp.ml[13];
 
-    t = (float) sqrt( frustumPlanes[2][0] * frustumPlanes[2][0] + 
+    t = (Number) sqrt( frustumPlanes[2][0] * frustumPlanes[2][0] + 
                       frustumPlanes[2][1] * frustumPlanes[2][1] + 
                       frustumPlanes[2][2] * frustumPlanes[2][2] );
 
@@ -163,7 +163,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[3][2] = mvp.ml[11] - mvp.ml[ 9];
     frustumPlanes[3][3] = mvp.ml[15] - mvp.ml[13];
 
-    t = (float) sqrt( frustumPlanes[3][0] * frustumPlanes[3][0] + 
+    t = (Number) sqrt( frustumPlanes[3][0] * frustumPlanes[3][0] + 
                       frustumPlanes[3][1] * frustumPlanes[3][1] + 
                       frustumPlanes[3][2] * frustumPlanes[3][2] );
 
@@ -181,7 +181,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[4][2] = mvp.ml[11] - mvp.ml[10];
     frustumPlanes[4][3] = mvp.ml[15] - mvp.ml[14];
 
-    t = (float) sqrt( frustumPlanes[4][0] * frustumPlanes[4][0] +  
+    t = (Number) sqrt( frustumPlanes[4][0] * frustumPlanes[4][0] +  
                       frustumPlanes[4][1] * frustumPlanes[4][1] + 
                       frustumPlanes[4][2] * frustumPlanes[4][2] );
 
@@ -199,7 +199,7 @@ void Camera::buildFrustrumPlanes() {
     frustumPlanes[5][2] = mvp.ml[11] + mvp.ml[10];
     frustumPlanes[5][3] = mvp.ml[15] + mvp.ml[14];
 
-    t = (float) sqrt( frustumPlanes[5][0] * frustumPlanes[5][0] + 
+    t = (Number) sqrt( frustumPlanes[5][0] * frustumPlanes[5][0] + 
                       frustumPlanes[5][1] * frustumPlanes[5][1] + 
                       frustumPlanes[5][2] * frustumPlanes[5][2] );
 

Core/Contents/Source/PolyCocoaCore.cpp

@@ -23,6 +23,39 @@ CocoaCore::CocoaCore(SubstanceView *view, int xRes, int yRes, bool fullScreen,in
 //	NSLog(@"BUNDLE: %@", [[NSBundle mainBundle] bundlePath]);
 	chdir([[[NSBundle mainBundle] bundlePath] UTF8String]);
 	
+	NSOpenGLPixelFormatAttribute attrs[32];
+	
+	int atindx = 0;
+	attrs[atindx++] = NSOpenGLPFADoubleBuffer;
+	
+	attrs[atindx++] = NSOpenGLPFADepthSize;
+	attrs[atindx++] = 32;
+	
+	if(aaLevel > 0) {
+		attrs[atindx++] = NSOpenGLPFASampleBuffers;	
+		attrs[atindx++] = 1;	
+	
+		attrs[atindx++] = NSOpenGLPFASamples;	
+		attrs[atindx++] = aaLevel;	
+	
+		attrs[atindx++] = NSOpenGLPFAMultisample;	
+	}
+	
+	attrs[atindx++] = NSOpenGLPFANoRecovery;		
+
+	if(fullScreen) {
+		
+//		attrs[atindx++] = NSOpenGLPFAFullScreen;		
+//		attrs[atindx++] = NSOpenGLPFAScreenMask;	
+//		attrs[atindx++] = CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay);
+		
+	}
+	
+	attrs[atindx++] = NSOpenGLPFAAccelerated;			
+	
+	
+	attrs[atindx++] = nil;				
+/*	
 	NSOpenGLPixelFormatAttribute attrs[] =
 	{
 			NSOpenGLPFADoubleBuffer,	
@@ -30,44 +63,60 @@ CocoaCore::CocoaCore(SubstanceView *view, int xRes, int yRes, bool fullScreen,in
 //		NSOpenGLPFAFullScreen,
 //		NSOpenGLPFAScreenMask,
 //		CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay),
-		//		NSOpenGLPFASampleBuffers, 1,
-//		NSOpenGLPFASamples,  aaLevel,
-//		NSOpenGLPFANoRecovery,	
+		NSOpenGLPFASampleBuffers, 1,
+		NSOpenGLPFASamples,  aaLevel,
+		NSOpenGLPFANoRecovery,	
 //		NSOpenGLPFAWindow,
-//		NSOpenGLPFAMultisample,
+		NSOpenGLPFAMultisample,
 //		NSOpenGLPFAAccelerated,
 //		NSOpenGLPFAAccumSize, 0,
 		nil
 	};	
-	
-	[view lockContext];
+*/
+
+//	[view lockContext];
 	
 	[view setCore:this];	
 	NSOpenGLPixelFormat *format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs];
+	
+	if(!format) {
+		NSLog(@"Error creating pixel format!\n");
+	}
+	
 	context = [[NSOpenGLContext alloc] initWithFormat: format shareContext:nil];
 
 	if (context == nil) {
         NSLog(@"Failed to create open gl context");
 	}	
 	
-	if(fullScreen) {
-	
-		[context makeCurrentContext];
-		[context setFullScreen];
-		CGDisplayCapture (kCGDirectMainDisplay ) ;		
-//		CGDisplayCapture (kCGDirectMainDisplay ) ;
-//		CGDisplaySwitchToMode (kCGDirectMainDisplay,
-//							   CGDisplayBestModeForParameters (kCGDirectMainDisplay,
-//															   32, xRes, yRes, NULL) );		
+	if(false) {
+
+//		[view enterFullScreenMode:[NSScreen mainScreen] withOptions:0];
+//		[view removeFromSuperview];
+//		[[view window] orderOut:nil];
+		
+//		CGDisplayCapture (kCGDirectMainDisplay ) ;			
+//		CGDisplaySwitchToMode (kCGDirectMainDisplay, CGDisplayBestModeForParameters (kCGDirectMainDisplay, 32, xRes, yRes, NULL) );				
 		
-		[context clearDrawable];
-        [context release];		
+		
+//		[context makeCurrentContext];		
+//		[context setFullScreen];
+//		[context flushBuffer];	
+//		CGDisplayCapture (kCGDirectMainDisplay ) ;		
+
+
+		
+//		[context clearDrawable];
+  //      [context release];		
 	} else {
 		[view clearGLContext];
 		[view setOpenGLContext:context];	
 		[context setView: view];					
 	}
 	
+	if(fullScreen) {
+	//	[view enterFullScreenMode:[NSScreen mainScreen] withOptions:0];	
+	}
 	
 	
 	glView = view;
@@ -80,7 +129,7 @@ CocoaCore::CocoaCore(SubstanceView *view, int xRes, int yRes, bool fullScreen,in
 	
 	renderer = new OpenGLRenderer();
 	services->setRenderer(renderer);	
-	[view unlockContext];			
+	//[view unlockContext];			
 	setVideoMode(xRes,yRes,fullScreen,aaLevel);		
 
 
@@ -115,14 +164,25 @@ void CocoaCore::setVideoMode(int xRes, int yRes, bool fullScreen, int aaLevel) {
 	dispatchEvent(new Event(), EVENT_CORE_RESIZE);	
 
 	
-	NSRect visibleFrame = [[NSScreen mainScreen] visibleFrame];	
-	NSRect frame = NSMakeRect([[glView window] frame].origin.x, [[glView window] frame].origin.y, xRes, yRes);
+//	NSRect visibleFrame = [[NSScreen mainScreen] visibleFrame];	
+//	NSRect frame = NSMakeRect([[glView window] frame].origin.x, [[glView window] frame].origin.y, xRes, yRes);
 	
 //	frame.origin.x = (visibleFrame.size.width - frame.size.width) * 0.5;
 //	frame.origin.y = (visibleFrame.size.height - frame.size.height) * (9.0/10.0);
 	
-	[[glView window] setFrame: frame display: YES animate: NO];
-	
+//	[[glView window] setFrame: frame display: YES animate: NO];
+//	if(!fullScreen) {
+		[[glView window] setContentSize: NSMakeSize(xRes, yRes)];
+//	} else {
+//		CGDisplaySwitchToMode (kCGDirectMainDisplay, CGDisplayBestModeForParameters (kCGDirectMainDisplay, 32, xRes, yRes, NULL) );						
+//	}
+	if(fullScreen) {	
+		CGDisplaySwitchToMode (kCGDirectMainDisplay, CGDisplayBestModeForParameters (kCGDirectMainDisplay, 32, xRes, yRes, NULL) );						
+		[glView enterFullScreenMode:[NSScreen mainScreen] withOptions:[NSDictionary dictionaryWithObjectsAndKeys:
+																	   nil]];
+		
+	}
+		
 	/*
 	if(aaLevel > 0) {
 		glEnable( GL_MULTISAMPLE_ARB );	
@@ -145,6 +205,12 @@ vector<Polycode::Rectangle> CocoaCore::getVideoModes() {
 }
 
 CocoaCore::~CocoaCore() {
+	
+	if(fullScreen) {
+		[glView exitFullScreenModeWithOptions:nil];
+		
+	}
+	
 	[glView clearGLContext];	
 	[context release];
 }
@@ -188,6 +254,11 @@ unsigned int CocoaCore::getTicks() {
 }
 
 void CocoaCore::enableMouse(bool newval) {
+	
+	if(newval) 
+		CGDisplayShowCursor(kCGDirectMainDisplay);			
+	else
+		CGDisplayHideCursor(kCGDirectMainDisplay);	
 	Core::enableMouse(newval);
 }
 
@@ -275,7 +346,7 @@ void CocoaCore::moveDiskItem(String itemPath, String destItemPath) {
 void CocoaCore::removeDiskItem(String itemPath) {
 	[[NSFileManager defaultManager] removeItemAtPath: [NSString stringWithUTF8String: itemPath.c_str()] error:nil];
 }
-
+	
 String CocoaCore::openFolderPicker() {
 	NSOpenPanel *attachmentPanel = [NSOpenPanel openPanel];	
 	[attachmentPanel setCanChooseFiles:NO];

Core/Contents/Source/PolyColor.cpp

@@ -15,7 +15,7 @@ Color::Color() : r(0),g(0),b(0),a(1){
 
 }
 
-Color::Color(float r,float g, float b, float a) {
+Color::Color(Number r,Number g, Number b, Number a) {
 	setColor(r,g,b,a);
 }
 
@@ -38,10 +38,10 @@ void Color::setColorHexRGB(unsigned int hex) {
 	int tg = (hex >> 8) & 0xFF;
 //	int ta = (hex ) & 0xFF;
 	
-	r = ((float)tr)/255.0f;
-	g = ((float)tg)/255.0f;
-	b = ((float)tb)/255.0f;
-//	a = ((float)ta)/255.0f;	
+	r = ((Number)tr)/255.0f;
+	g = ((Number)tg)/255.0f;
+	b = ((Number)tb)/255.0f;
+//	a = ((Number)ta)/255.0f;	
 	
 }
 
@@ -51,27 +51,27 @@ void Color::setColorHex(unsigned int hex) {
 	int tb = (hex >> 8) & 0xFF;
 	int ta = (hex ) & 0xFF;
 	
-	r = ((float)tr)/255.0f;
-	g = ((float)tg)/255.0f;
-	b = ((float)tb)/255.0f;
-	a = ((float)ta)/255.0f;	
+	r = ((Number)tr)/255.0f;
+	g = ((Number)tg)/255.0f;
+	b = ((Number)tb)/255.0f;
+	a = ((Number)ta)/255.0f;	
 }
 
-float Color::getBrightness() {
+Number Color::getBrightness() {
 	return (r+g+b) / 3.0f;
 }
 
-void Color::setColorHSV(float H, float S, float V) {
-	float r,g,b;
+void Color::setColorHSV(Number H, Number S, Number V) {
+	Number r,g,b;
     
 	if (S == 0) {
         r = g = b = V;
     } else {
         int i = (int)(H/60.0f);
-        float f = (H/60.0f) - (float)i;
-        float p = V*(1.0f-S);
-        float q = V*(1.0f-S*f);
-        float t = V*(1.0f-(1.0f-f)*S);
+        Number f = (H/60.0f) - (Number)i;
+        Number p = V*(1.0f-S);
+        Number q = V*(1.0f-S*f);
+        Number t = V*(1.0f-(1.0f-f)*S);
         switch (i) {
             case 0: r = V;   g = t;  b = p;  break;
             case 1: r = q;  g = V;   b = p;  break;
@@ -86,20 +86,20 @@ void Color::setColorHSV(float H, float S, float V) {
 }
 
 void Color::Random() {
-	setColor((float)rand()/RAND_MAX, (float)rand()/RAND_MAX, (float)rand()/RAND_MAX, 1.0f);
+	setColor((Number)rand()/RAND_MAX, (Number)rand()/RAND_MAX, (Number)rand()/RAND_MAX, 1.0f);
 }
 
 void Color::setColorRGB(int r, int g, int b) {
-	this->r = ((float)r)/255.0f;
-	this->g = ((float)g)/255.0f;
-	this->b = ((float)b)/255.0f;
+	this->r = ((Number)r)/255.0f;
+	this->g = ((Number)g)/255.0f;
+	this->b = ((Number)b)/255.0f;
 }
 	
 void Color::setColorRGBA(int r, int g, int b, int a) {
-	this->r = ((float)r)/255.0f;
-	this->g = ((float)g)/255.0f;
-	this->b = ((float)b)/255.0f;
-	this->a = ((float)a)/255.0f;
+	this->r = ((Number)r)/255.0f;
+	this->g = ((Number)g)/255.0f;
+	this->b = ((Number)b)/255.0f;
+	this->a = ((Number)a)/255.0f;
 }
 
 void Color::setColor(Color *color) {
@@ -110,7 +110,7 @@ void Color::setColor(Color *color) {
 }
 
 
-void Color::setColor(float r, float g, float b, float a) {
+void Color::setColor(Number r, Number g, Number b, Number a) {
 	this->r = r;
 	this->g = g;
 	this->b = b;

Core/Contents/Source/PolyConfig.cpp

@@ -62,7 +62,7 @@ void Config::saveConfig(String configNamespace, String fileName) {
 			if(entries[i]->isString)
 				node->LinkEndChild( new	TiXmlText(entries[i]->stringVal.c_str()));  
 			else
-				node->LinkEndChild( new	TiXmlText(String::floatToString(entries[i]->numVal).c_str()));  						
+				node->LinkEndChild( new	TiXmlText(String::NumberToString(entries[i]->numVal).c_str()));  						
 			root->LinkEndChild( node);		
 		}
 	}
@@ -91,13 +91,13 @@ void Config::setStringValue(String configNamespace, String key, String value) {
 	getEntry(configNamespace, key)->isString = true;	
 }
 
-void Config::setNumericValue(String configNamespace, String key, float value) {
+void Config::setNumericValue(String configNamespace, String key, Number value) {
 	getEntry(configNamespace, key)->numVal = value;	
 	getEntry(configNamespace, key)->isString = false;		
 }
 
 
-float Config::getNumericValue(String configNamespace, String key) {
+Number Config::getNumericValue(String configNamespace, String key) {
 	return getEntry(configNamespace, key)->numVal;
 }
 

Core/Contents/Source/PolyCore.cpp

@@ -37,11 +37,11 @@ namespace Polycode {
 		return numVideoModes;
 	}
 	
-	float Core::getXRes() {
+	Number Core::getXRes() {
 		return xRes;
 	}
 
-	float Core::getYRes() {
+	Number Core::getYRes() {
 		return yRes;
 	}
 	
@@ -58,12 +58,12 @@ namespace Polycode {
 		running = false;
 	}
 	
-	float Core::getElapsed() {
-		return ((float)elapsed)/1000.0f;
+	Number Core::getElapsed() {
+		return ((Number)elapsed)/1000.0f;
 	}
 	
-	float Core::getTicksFloat() {
-		return ((float)getTicks())/1000.0f;		
+	Number Core::getTicksFloat() {
+		return ((Number)getTicks())/1000.0f;		
 	}
 	
 	void Core::setVideoModeIndex(int index, bool fullScreen, int aaLevel) {
@@ -101,7 +101,7 @@ namespace Polycode {
 	}
 	
 	
-	float Core::getFPS() {
+	Number Core::getFPS() {
 		return fps;
 	}
 	

Core/Contents/Source/PolyCoreInput.cpp

@@ -60,8 +60,8 @@ namespace Polycode {
 	}
 	
 	void CoreInput::setDeltaPosition(int x, int y) {
-		deltaMousePosition.x = (float)x;
-		deltaMousePosition.y = (float)y;
+		deltaMousePosition.x = (Number)x;
+		deltaMousePosition.y = (Number)y;
 	}
 
 	Vector2 CoreInput::getMousePosition() {

Core/Contents/Source/PolyCoreServices.cpp

@@ -113,7 +113,9 @@ void CoreServices::handleEvent(Event *event) {
 				dispatchEvent(new InputEvent(inputEvent->key, inputEvent->charCode, inputEvent->timestamp), inputEvent->getEventCode());			
 			break;
 			default:
-				dispatchEvent(new InputEvent(inputEvent->mousePosition, inputEvent->timestamp), inputEvent->getEventCode());			
+				InputEvent *_inputEvent = new InputEvent(inputEvent->mousePosition, inputEvent->timestamp);
+				_inputEvent->mouseButton = inputEvent->mouseButton;
+				dispatchEvent(_inputEvent, inputEvent->getEventCode());			
 			break;
 		}
 	}

Core/Contents/Source/PolyEntity.cpp

@@ -18,6 +18,7 @@ Entity::Entity() {
 	roll = 0;
 	renderer = NULL;
 	enabled = true;
+	depthTest = true;
 	visible = true;
 	bBoxRadius = 0;
 	color.setColor(1.0f,1.0f,1.0f,1.0f);
@@ -29,6 +30,7 @@ Entity::Entity() {
 	backfaceCulled = true;
 	depthOnly = false;
 	depthWrite = true;
+	ignoreParentMatrix = false;
 	alphaTest = false;
 	blendingMode = Renderer::BLEND_MODE_NORMAL;	
 	lockMatrix = false;
@@ -111,7 +113,7 @@ void Entity::setColorInt(int r, int g, int b, int a) {
 	color.setColorRGBA(r,g, b, a);
 }
 
-void Entity::setColor(float r, float g, float b, float a) {
+void Entity::setColor(Number r, Number g, Number b, Number a) {
 	color.setColor(r,g,b,a);
 }
 
@@ -123,9 +125,9 @@ void Entity::setBlendingMode(int newBlendingMode) {
 	blendingMode = newBlendingMode;
 }
 
-float Entity::getBBoxRadius() {
-	float compRad;
-	float biggest = bBoxRadius;
+Number Entity::getBBoxRadius() {
+	Number compRad;
+	Number biggest = bBoxRadius;
 	for(int i=0;i<children.size();i++) {
 		compRad = children[i]->getCompoundBBoxRadius();
 		if(compRad > biggest)
@@ -134,9 +136,9 @@ float Entity::getBBoxRadius() {
 	return biggest;
 }
 
-float Entity::getCompoundBBoxRadius() {
-	float compRad;
-	float biggest = bBoxRadius + position.distance(Vector3(0,0,0));
+Number Entity::getCompoundBBoxRadius() {
+	Number compRad;
+	Number biggest = bBoxRadius + position.distance(Vector3(0,0,0));
 	for(int i=0;i<children.size();i++) {
 		compRad = children[i]->getCompoundBBoxRadius();
 		if(compRad > biggest)
@@ -145,7 +147,7 @@ float Entity::getCompoundBBoxRadius() {
 	return biggest;
 }
 
-void Entity::setBBoxRadius(float rad) {
+void Entity::setBBoxRadius(Number rad) {
 	bBoxRadius = rad;
 }
 
@@ -236,6 +238,10 @@ void Entity::setMask(Entity *mask) {
 	mask->enabled = false;
 	maskEntity = mask;
 	hasMask = true;
+	
+//	for(int i=0; i < children.size(); i++) {
+//		children[i]->setMask(mask);
+//	}
 }
 
 void Entity::clearMask() {
@@ -271,7 +277,11 @@ void Entity::transformAndRender() {
 	}
 	
 	renderer->pushMatrix();	
-	renderer->multModelviewMatrix(transformMatrix);
+	if(ignoreParentMatrix && parentEntity) {
+		renderer->multModelviewMatrix(parentEntity->getConcatenatedMatrix().inverse());
+	}else {
+		renderer->multModelviewMatrix(transformMatrix);
+	}
 	renderer->setVertexColor(color.r,color.g,color.b,color.a);
 	if(billboardMode) {
 		renderer->billboardMatrixWithScale(getCompoundScale());
@@ -279,12 +289,22 @@ void Entity::transformAndRender() {
 			renderer->multModelviewMatrix(getConcatenatedRollMatrix());
 		}
 	}
-		
+
+	if(hasMask) {
+		renderer->enableDepthWrite(false);
+		renderer->enableDepthTest(true);		
+	} else {
 	if(!depthWrite)
+		renderer->enableDepthWrite(false);
+	else
+		renderer->enableDepthWrite(true);
+	
+	if(!depthTest) 
 		renderer->enableDepthTest(false);
 	else
 		renderer->enableDepthTest(true);
-		
+	}
+		 
 	renderer->enableAlphaTest(alphaTest);
 	
 	Color combined = getCombinedColor();
@@ -315,8 +335,8 @@ void Entity::transformAndRender() {
 		renderer->clearBuffer(false, true);
 	}
 	
-	if(!depthWrite)
-		renderer->enableDepthTest(true);
+//	if(!depthWrite)
+//		renderer->enableDepthWrite(true);
 	
 	
 	if(hasMask) {
@@ -339,6 +359,10 @@ void Entity::addEntity(Entity *newChild) {
 	newChild->setRenderer(renderer);
 	newChild->setParentEntity(this);
 	children.push_back(newChild);
+	
+	if(hasMask) {
+		newChild->setMask(maskEntity);
+	}
 }
 
 
@@ -352,7 +376,7 @@ void Entity::dirtyMatrix(bool val) {
 	matrixDirty = val;
 }
 
-void Entity::setRotationQuat(float w, float x, float y, float z) {
+void Entity::setRotationQuat(Number w, Number x, Number y, Number z) {
 	rotationQuat.w = w;
 	rotationQuat.x = x;
 	rotationQuat.y = y;
@@ -364,13 +388,13 @@ Quaternion Entity::getRotationQuat() {
 	return rotationQuat;
 }
 
-void Entity::setPitch(float pitch) {
+void Entity::setPitch(Number pitch) {
 	this->pitch = pitch;
 	rebuildRotation();	
 	matrixDirty = true;
 }
 
-void Entity::setYaw(float yaw) {
+void Entity::setYaw(Number yaw) {
 	this->yaw = yaw;
 	rebuildRotation();	
 	matrixDirty = true;
@@ -391,25 +415,25 @@ Matrix4 Entity::getTransformMatrix() {
 	return transformMatrix;
 }
 
-void Entity::Pitch(float pitch) {
+void Entity::Pitch(Number pitch) {
 	this->pitch += pitch;
 	rebuildRotation();	
 	matrixDirty = true;
 }
 
-void Entity::Yaw(float yaw) {
+void Entity::Yaw(Number yaw) {
 	this->yaw += yaw;
 	rebuildRotation();	
 	matrixDirty = true;
 }
 
-void Entity::Roll(float roll) {
+void Entity::Roll(Number roll) {
 	this->roll += roll;
 	rebuildRotation();
 	matrixDirty = true;
 }
 
-void Entity::setRoll(float roll) {
+void Entity::setRoll(Number roll) {
 	this->roll= roll;
 	rebuildRotation();
 	matrixDirty = true;
@@ -439,15 +463,15 @@ void Entity::setParentEntity(Entity *entity) {
 	parentEntity = entity;
 }
 
-float Entity::getPitch() {
+Number Entity::getPitch() {
 	return pitch;
 }
 
-float Entity::getYaw() {
+Number Entity::getYaw() {
 	return yaw;
 }
 
-float Entity::getRoll() {
+Number Entity::getRoll() {
 	return roll;
 }
 
@@ -457,7 +481,7 @@ void Entity::setTransformByMatrixPure(Matrix4 matrix) {
 
 void Entity::setTransformByMatrix(Matrix4 matrix) {
 	setPosition(matrix.getPosition());	
-	float x,y,z;
+	Number x,y,z;
 	matrix.getEulerAngles(&x,&y,&z);
 
 	setPitch(x);
@@ -475,39 +499,39 @@ void Entity::setPosition(Vector3 posVec) {
 	matrixDirty = true;
 }
 
-void Entity::setPositionX(float x) {
+void Entity::setPositionX(Number x) {
 	position.x = x;
 	matrixDirty = true;
 }
 
-void Entity::setPositionY(float y) {
+void Entity::setPositionY(Number y) {
 	position.y = y;
 	matrixDirty = true;	
 }
 
-void Entity::setPositionZ(float z) {
+void Entity::setPositionZ(Number z) {
 	position.z = z;
 	matrixDirty = true;	
 }
 
 
-void Entity::setScaleX(float x) {
+void Entity::setScaleX(Number x) {
 	scale.x = x;
 	matrixDirty = true;	
 }
 
-void Entity::setScaleY(float y) {
+void Entity::setScaleY(Number y) {
 	scale.y = y;
 	matrixDirty = true;		
 }
 
-void Entity::setScaleZ(float z) {
+void Entity::setScaleZ(Number z) {
 	scale.z = z;
 	matrixDirty = true;		
 }
 
 
-void Entity::setPosition(float x, float y, float z) {
+void Entity::setPosition(Number x, Number y, Number z) {
 	position.x = x;
 	position.y = y;
 	position.z = z;
@@ -519,21 +543,21 @@ void Entity::Translate(Vector3 tVec) {
 	matrixDirty = true;
 }
 
-void Entity::Translate(float x, float y, float z) {
+void Entity::Translate(Number x, Number y, Number z) {
 	position.x += x;
 	position.y += y;
 	position.z += z;
 	matrixDirty = true;
 }
 
-void Entity::Scale(float x, float y, float z) {
+void Entity::Scale(Number x, Number y, Number z) {
 	scale.x *= x;
 	scale.y *= y;
 	scale.z *= z;	
 	matrixDirty = true;
 }
 
-void Entity::setScale(float x, float y, float z) {
+void Entity::setScale(Number x, Number y, Number z) {
 	scale.x = x;
 	scale.y = y;
 	scale.z = z;
@@ -544,21 +568,21 @@ Vector3 *Entity::getPosition() {
 	return &position;
 }
 
-float Entity::getCombinedPitch() {
+Number Entity::getCombinedPitch() {
 	if(parentEntity != NULL)
 		return parentEntity->getCombinedPitch()+pitch;
 	else
 		return pitch;
 }
 
-float Entity::getCombinedYaw() {
+Number Entity::getCombinedYaw() {
 	if(parentEntity != NULL)
 		return parentEntity->getCombinedYaw()+yaw;
 	else
 		return yaw;
 }
 
-float Entity::getCombinedRoll() {
+Number Entity::getCombinedRoll() {
 	if(parentEntity != NULL)
 		return parentEntity->getCombinedRoll()+roll;
 	else

Core/Contents/Source/PolyGLES1Renderer.cpp

@@ -71,7 +71,7 @@ void OpenGLES1Renderer::setLineSmooth(bool val) {
 		glDisable(GL_LINE_SMOOTH);
 }
 
-void OpenGLES1Renderer::setFOV(float fov) {
+void OpenGLES1Renderer::setFOV(Number fov) {
 	this->fov = fov;
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -81,7 +81,7 @@ void OpenGLES1Renderer::setFOV(float fov) {
 	glMatrixMode(GL_MODELVIEW);	
 }
 
-void OpenGLES1Renderer::setViewportSize(int w, int h, float fov) {
+void OpenGLES1Renderer::setViewportSize(int w, int h, Number fov) {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 	gluPerspective(fov,(GLfloat)w/(GLfloat)h,nearPlane,farPlane);
@@ -90,7 +90,7 @@ void OpenGLES1Renderer::setViewportSize(int w, int h, float fov) {
 	glMatrixMode(GL_MODELVIEW);
 }
 
-Vector3 OpenGLES1Renderer::Unproject(float x, float y) {
+Vector3 OpenGLES1Renderer::Unproject(Number x, Number y) {
 	Vector3 coords;
 	GLfloat wx, wy, wz;
 	GLfloat cx, cy, cz;
@@ -104,8 +104,8 @@ Vector3 OpenGLES1Renderer::Unproject(float x, float y) {
 	GLint vp[4];
 	glGetIntegerv( GL_VIEWPORT, vp );
 	
-	wx = ( float ) x;
-	wy = ( float ) vp[3] - ( float ) y;
+	wx = ( Number ) x;
+	wy = ( Number ) vp[3] - ( Number ) y;
 	glReadPixels( x, wy, 1, 1, GL_DEPTH_COMPONENT16_OES, GL_FLOAT, &wz );
 	
 	gluUnProject((GLdouble)wx, (GLdouble)wy, (GLdouble)wz, (GLdouble*)mv, (GLdouble*)proj, vp, (GLdouble*)&cx, (GLdouble*)&cy, (GLdouble*)&cz );
@@ -116,7 +116,7 @@ Vector3 OpenGLES1Renderer::Unproject(float x, float y) {
 	
 }
 
-bool OpenGLES1Renderer::test2DCoordinate(float x, float y, Poly::Polygon *poly, const Matrix4 &matrix, bool billboardMode) {
+bool OpenGLES1Renderer::test2DCoordinate(Number x, Number y, Poly::Polygon *poly, const Matrix4 &matrix, bool billboardMode) {
 	GLfloat nearPlane[3],farPlane[3];
 	
 	GLfloat mv[16];
@@ -180,7 +180,7 @@ void OpenGLES1Renderer::enableLighting(bool enable) {
 	lightingEnabled = enable;
 }
 
-void OpenGLES1Renderer::setLineSize(float lineSize) {
+void OpenGLES1Renderer::setLineSize(Number lineSize) {
 	glLineWidth(lineSize);
 }
 
@@ -244,13 +244,13 @@ void OpenGLES1Renderer::setBlendingMode(int blendingMode) {
 }
 
 Matrix4 OpenGLES1Renderer::getProjectionMatrix() {
-	float m[16];
+	Number m[16];
 	glGetFloatv( GL_PROJECTION_MATRIX, m);
 	return Matrix4(m);
 }
 
 Matrix4 OpenGLES1Renderer::getModelviewMatrix() {
-	float m[16];
+	Number m[16];
     glGetFloatv( GL_MODELVIEW_MATRIX, m);
 	return Matrix4(m);
 }
@@ -268,7 +268,7 @@ void OpenGLES1Renderer::renderToTexture(Texture *targetTexture) {
 	
 }
 
-void OpenGLES1Renderer::setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth) {
+void OpenGLES1Renderer::setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth) {
 	switch(fogMode) {
 		case FOG_LINEAR:
 			glFogx(GL_FOG_MODE, GL_LINEAR);
@@ -340,7 +340,7 @@ void OpenGLES1Renderer::BeginRender() {
 	currentTexture = NULL;
 }
 
-void OpenGLES1Renderer::setClearColor(float r, float g, float b) {
+void OpenGLES1Renderer::setClearColor(Number r, Number g, Number b) {
 	clearColor.setColor(r,g,b,1.0f);	
 	glClearColor(r,g,b,0.0f);
 }
@@ -349,7 +349,7 @@ void OpenGLES1Renderer::translate3D(Vector3 *position) {
 	glTranslatef(position->x, position->y, position->z);
 }
 
-void OpenGLES1Renderer::translate3D(float x, float y, float z) {
+void OpenGLES1Renderer::translate3D(Number x, Number y, Number z) {
 	glTranslatef(x, y, z);
 }
 
@@ -613,12 +613,12 @@ void OpenGLES1Renderer::draw3DVertex(Vertex *vertex, Vector2 *faceUV) {
 	 */
 }
 
-void OpenGLES1Renderer::drawScreenQuad(float qx, float qy) {
+void OpenGLES1Renderer::drawScreenQuad(Number qx, Number qy) {
 	/*
 	setOrthoMode();
 	
-	float xscale = qx/((float)getXRes()) * 2.0f;
-	float yscale = qy/((float)getYRes()) * 2.0f;
+	Number xscale = qx/((Number)getXRes()) * 2.0f;
+	Number yscale = qy/((Number)getYRes()) * 2.0f;
 	
 	glBegin(GL_QUADS);
 	glColor4f(1.0f,1.0f,1.0f,1.0f);
@@ -650,7 +650,7 @@ void OpenGLES1Renderer::draw2DVertex(Vertex *vertex) {
 	 */
 }
 
-void OpenGLES1Renderer::draw3DLine(Vector3 origin, Vector3 direction, float length, Color color)  {
+void OpenGLES1Renderer::draw3DLine(Vector3 origin, Vector3 direction, Number length, Color color)  {
 	/*
 	glColor4f(color.r,color.g,color.b,color.a);	
 	//	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
@@ -661,7 +661,7 @@ void OpenGLES1Renderer::draw3DLine(Vector3 origin, Vector3 direction, float leng
 	 */
 }
 
-void OpenGLES1Renderer::translate2D(float x, float y) {
+void OpenGLES1Renderer::translate2D(Number x, Number y) {
 	glTranslatef(x, y, 0.0f);
 }
 
@@ -675,11 +675,11 @@ void OpenGLES1Renderer::loadIdentity() {
 	glLoadIdentity();
 }
 
-void OpenGLES1Renderer::rotate2D(float angle) {
+void OpenGLES1Renderer::rotate2D(Number angle) {
 	glRotatef(angle, 0.0f, 0.0f, 1.0f);
 }
 
-void OpenGLES1Renderer::setVertexColor(float r, float g, float b, float a) {
+void OpenGLES1Renderer::setVertexColor(Number r, Number g, Number b, Number a) {
 	glColor4f(r,g,b,a);
 }
 

Core/Contents/Source/PolyGLRenderer.cpp

@@ -122,7 +122,7 @@ void OpenGLRenderer::Resize(int xRes, int yRes) {
 	
 	glLineWidth(1.0f);
 	
-	glEnable(GL_LINE_SMOOTH);
+//	glEnable(GL_LINE_SMOOTH);
 	
 	GLint numBuffers;
 	glGetIntegerv(GL_MAX_DRAW_BUFFERS, &numBuffers);
@@ -157,7 +157,7 @@ void OpenGLRenderer::setLineSmooth(bool val) {
 		glDisable(GL_LINE_SMOOTH);
 }
 
-void OpenGLRenderer::setFOV(float fov) {
+void OpenGLRenderer::setFOV(Number fov) {
 	this->fov = fov;
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
@@ -167,7 +167,7 @@ void OpenGLRenderer::setFOV(float fov) {
 	glMatrixMode(GL_MODELVIEW);	
 }
 
-void OpenGLRenderer::setViewportSize(int w, int h, float fov) {
+void OpenGLRenderer::setViewportSize(int w, int h, Number fov) {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 	gluPerspective(fov,(GLfloat)w/(GLfloat)h,nearPlane,farPlane);
@@ -176,7 +176,7 @@ void OpenGLRenderer::setViewportSize(int w, int h, float fov) {
 	glMatrixMode(GL_MODELVIEW);
 }
 
-Vector3 OpenGLRenderer::Unproject(float x, float y) {
+Vector3 OpenGLRenderer::Unproject(Number x, Number y) {
 	Vector3 coords;
 	GLfloat wx, wy, wz;
 	GLdouble cx, cy, cz;
@@ -190,8 +190,8 @@ Vector3 OpenGLRenderer::Unproject(float x, float y) {
 	GLint vp[4];
 	glGetIntegerv( GL_VIEWPORT, vp );
 	
-	wx = ( float ) x;
-	wy = ( float ) vp[3] - ( float ) y;
+	wx = ( Number ) x;
+	wy = ( Number ) vp[3] - ( Number ) y;
 	glReadPixels( x, wy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &wz );
 	
 	gluUnProject( wx, wy, wz, mv, proj, vp, &cx, &cy, &cz );
@@ -202,7 +202,7 @@ Vector3 OpenGLRenderer::Unproject(float x, float y) {
 	
 }
 
-bool OpenGLRenderer::test2DCoordinate(float x, float y, Polycode::Polygon *poly, const Matrix4 &matrix, bool billboardMode) {
+bool OpenGLRenderer::test2DCoordinate(Number x, Number y, Polycode::Polygon *poly, const Matrix4 &matrix, bool billboardMode) {
 	GLdouble nearPlane[3],farPlane[3];
 	
 	GLdouble mv[16];
@@ -241,32 +241,34 @@ bool OpenGLRenderer::test2DCoordinate(float x, float y, Polycode::Polygon *poly,
 	}
 }
 
-void OpenGLRenderer::enableDepthTest(bool val) {
-//	if(val)
-//		glEnable(GL_DEPTH_TEST);
-//	else
-//		glDisable(GL_DEPTH_TEST);
+void OpenGLRenderer::enableDepthWrite(bool val) {
 	if(val)
 		glDepthMask(GL_TRUE);
 	else
-		glDepthMask(GL_FALSE);
-	
+		glDepthMask(GL_FALSE);	
+}
+
+void OpenGLRenderer::enableDepthTest(bool val) {
+	if(val)
+		glEnable(GL_DEPTH_TEST);
+	else
+		glDisable(GL_DEPTH_TEST);	
 }
 
 void OpenGLRenderer::setModelviewMatrix(Matrix4 m) {
-	glLoadMatrixf(m.ml);
+	glLoadMatrixd(m.ml);
 }
 
 void OpenGLRenderer::multModelviewMatrix(Matrix4 m) {
 //	glMatrixMode(GL_MODELVIEW);
-	glMultMatrixf(m.ml);
+	glMultMatrixd(m.ml);
 }
 
 void OpenGLRenderer::enableLighting(bool enable) {
 	lightingEnabled = enable;
 }
 
-void OpenGLRenderer::setLineSize(float lineSize) {
+void OpenGLRenderer::setLineSize(Number lineSize) {
 	glLineWidth(lineSize);
 }
 
@@ -281,10 +283,10 @@ void OpenGLRenderer::drawVertexBuffer(VertexBuffer *buffer) {
 	glEnableClientState(GL_VERTEX_ARRAY);		
 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 	glEnableClientState(GL_NORMAL_ARRAY);	
-	glEnableClientState(GL_COLOR_ARRAY);		
+//	glEnableClientState(GL_COLOR_ARRAY);		
 		
-	glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getColorBufferID());
-	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );	
+//	glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getColorBufferID());
+//	glTexCoordPointer( 4, GL_FLOAT, 0, (char *) NULL );	
 	glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getVertexBufferID());
 	glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );	
 	glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getNormalBufferID());
@@ -292,15 +294,54 @@ void OpenGLRenderer::drawVertexBuffer(VertexBuffer *buffer) {
 	glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getTextCoordBufferID());
 	glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );
 	
-	if(buffer->verticesPerFace == 3)
-		glDrawArrays( GL_TRIANGLES, 0, buffer->getVertexCount() );
-	else
-		glDrawArrays( GL_QUADS, 0, buffer->getVertexCount() );
+	
+	GLenum mode = GL_TRIANGLES;
+	
+	switch(buffer->meshType) {
+		case Mesh::TRI_MESH:
+			switch(renderMode) {
+				case RENDER_MODE_NORMAL:
+					mode = GL_TRIANGLES;
+					break;
+				case RENDER_MODE_WIREFRAME:
+					mode = GL_LINE_LOOP;
+					break;
+			}
+			break;
+		case Mesh::TRIFAN_MESH:
+			switch(renderMode) {
+				case RENDER_MODE_NORMAL:
+					mode = GL_TRIANGLE_FAN;
+					break;
+				case RENDER_MODE_WIREFRAME:
+					mode = GL_LINE_LOOP;
+					break;
+			}
+			break;
+		case Mesh::QUAD_MESH:
+			switch(renderMode) {
+				case RENDER_MODE_NORMAL:
+					mode = GL_QUADS;
+					break;
+				case RENDER_MODE_WIREFRAME:
+					mode = GL_LINE_LOOP;
+					break;
+			}
+			break;
+		case Mesh::LINE_MESH:
+			mode = GL_LINES;
+			break;	
+		case Mesh::POINT_MESH:
+			mode = GL_POINTS;
+			break;
+	}	
+	
+	glDrawArrays( mode, 0, buffer->getVertexCount() );
 	
 	glDisableClientState( GL_VERTEX_ARRAY);	
 	glDisableClientState( GL_TEXTURE_COORD_ARRAY );		
 	glDisableClientState( GL_NORMAL_ARRAY );
-	glDisableClientState( GL_COLOR_ARRAY );	
+//	glDisableClientState( GL_COLOR_ARRAY );	
 }
 
 void OpenGLRenderer::enableFog(bool enable) {
@@ -331,14 +372,14 @@ void OpenGLRenderer::setBlendingMode(int blendingMode) {
 }
 
 Matrix4 OpenGLRenderer::getProjectionMatrix() {
-	float m[16];
-	glGetFloatv( GL_PROJECTION_MATRIX, m);
+	Number m[16];
+	glGetDoublev( GL_PROJECTION_MATRIX, m);
 	return Matrix4(m);
 }
 
 Matrix4 OpenGLRenderer::getModelviewMatrix() {
-	float m[16];
-    glGetFloatv( GL_MODELVIEW_MATRIX, m);
+	Number m[16];
+    glGetDoublev( GL_MODELVIEW_MATRIX, m);
 	return Matrix4(m);
 }
 
@@ -355,7 +396,7 @@ void OpenGLRenderer::renderToTexture(Texture *targetTexture) {
 
 }
 
-void OpenGLRenderer::setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth) {
+void OpenGLRenderer::setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth) {
 	switch(fogMode) {
 		case FOG_LINEAR:
 			glFogi(GL_FOG_MODE, GL_LINEAR);
@@ -380,7 +421,20 @@ void OpenGLRenderer::setFogProperties(int fogMode, Color color, float density, f
 	glClearColor(color.r, color.g, color.b, color.a);
 }
 
-void OpenGLRenderer::setOrthoMode(float xSize, float ySize) {
+
+void OpenGLRenderer::_setOrthoMode() {
+	if(!orthoMode) {
+		glMatrixMode(GL_PROJECTION);
+		glPushMatrix();
+		glLoadIdentity();
+		glOrtho(-1,1,-1,1,nearPlane,farPlane);
+		orthoMode = true;
+	}
+	glMatrixMode(GL_MODELVIEW);	
+	glLoadIdentity();	
+}
+
+void OpenGLRenderer::setOrthoMode(Number xSize, Number ySize) {
 	
 	if(xSize == 0)
 		xSize = xRes;
@@ -433,7 +487,7 @@ void OpenGLRenderer::BeginRender() {
 	currentTexture = NULL;
 }
 
-void OpenGLRenderer::setClearColor(float r, float g, float b) {
+void OpenGLRenderer::setClearColor(Number r, Number g, Number b) {
 	clearColor.setColor(r,g,b,1.0f);	
 	glClearColor(r,g,b,0.0f);
 }
@@ -442,7 +496,7 @@ void OpenGLRenderer::translate3D(Vector3 *position) {
 	glTranslatef(position->x, position->y, position->z);
 }
 
-void OpenGLRenderer::translate3D(float x, float y, float z) {
+void OpenGLRenderer::translate3D(Number x, Number y, Number z) {
 	glTranslatef(x, y, z);
 }
 
@@ -653,7 +707,7 @@ void OpenGLRenderer::pushRenderDataArray(RenderDataArray *array) {
 			glVertexPointer(array->size, GL_FLOAT, 0, array->arrayPtr);
 			verticesToDraw = array->count;
 		break;
-		case RenderDataArray::COLOR_DATA_ARRAY:			
+		case RenderDataArray::COLOR_DATA_ARRAY:		
 			glColorPointer(array->size, GL_FLOAT, 0, array->arrayPtr);			
 			glEnableClientState(GL_COLOR_ARRAY);
 		break;
@@ -791,7 +845,7 @@ RenderDataArray *OpenGLRenderer::createRenderDataArray(int arrayType) {
 	return newArray;
 }
 
-void OpenGLRenderer::setRenderArrayData(RenderDataArray *array, float *arrayData) {
+void OpenGLRenderer::setRenderArrayData(RenderDataArray *array, Number *arrayData) {
 	
 }
 
@@ -832,7 +886,10 @@ void OpenGLRenderer::drawArrays(int drawType) {
 			break;
 		case Mesh::LINE_MESH:
 			mode = GL_LINES;
-			break;			
+			break;	
+		case Mesh::POINT_MESH:
+			mode = GL_POINTS;
+		break;
 	}
 	
 	glDrawArrays( mode, 0, verticesToDraw);	
@@ -860,11 +917,11 @@ void OpenGLRenderer::draw3DVertex2UV(Vertex *vertex, Vector2 *faceUV1, Vector2 *
 }
 */
 
-void OpenGLRenderer::drawScreenQuad(float qx, float qy) {
+void OpenGLRenderer::drawScreenQuad(Number qx, Number qy) {
 	setOrthoMode();
 	
-	float xscale = qx/((float)getXRes()) * 2.0f;
-	float yscale = qy/((float)getYRes()) * 2.0f;
+	Number xscale = qx/((Number)getXRes()) * 2.0f;
+	Number yscale = qy/((Number)getYRes()) * 2.0f;
 
 	glBegin(GL_QUADS);
 		glColor4f(1.0f,1.0f,1.0f,1.0f);
@@ -885,7 +942,7 @@ void OpenGLRenderer::drawScreenQuad(float qx, float qy) {
 }
 
 
-void OpenGLRenderer::translate2D(float x, float y) {
+void OpenGLRenderer::translate2D(Number x, Number y) {
 	glTranslatef(x, y, 0.0f);
 }
 
@@ -894,16 +951,15 @@ void OpenGLRenderer::scale2D(Vector2 *scale) {
 }
 
 void OpenGLRenderer::loadIdentity() {
-	setBlendingMode(BLEND_MODE_NORMAL);
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
 }
 
-void OpenGLRenderer::rotate2D(float angle) {
+void OpenGLRenderer::rotate2D(Number angle) {
 	glRotatef(angle, 0.0f, 0.0f, 1.0f);
 }
 
-void OpenGLRenderer::setVertexColor(float r, float g, float b, float a) {
+void OpenGLRenderer::setVertexColor(Number r, Number g, Number b, Number a) {
 	glColor4f(r,g,b,a);
 }
 

Core/Contents/Source/PolyGLVertexBuffer.cpp

@@ -17,7 +17,7 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	} else {
 		verticesPerFace = 3;				
 	}
-
+	meshType = mesh->getMeshType();
 	
 	glGenBuffersARB(1, &vertexBufferID);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBufferID);
@@ -45,7 +45,7 @@ OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
 	glGenBuffersARB(1, &texCoordBufferID);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, texCoordBufferID);
 	
-	bufferSize = 0;
+	bufferSize = 0;	
 	newBufferSize = 0;		
 	buffer = (GLfloat*)malloc(1);	
 	

Core/Contents/Source/PolyGenericScene.cpp

@@ -95,6 +95,9 @@ void GenericScene::Render() {
 	defaultCamera->doCameraTransform();
 	defaultCamera->buildFrustrumPlanes();
 	
+	if(defaultCamera->getOrthoMode()) {
+		CoreServices::getInstance()->getRenderer()->_setOrthoMode();
+	}
 	
 	for(int i=0; i<entities.size();i++) {
 		if(entities[i]->getBBoxRadius() > 0) {
@@ -104,6 +107,11 @@ void GenericScene::Render() {
 			entities[i]->transformAndRender();		
 		}
 	}
+	
+	if(defaultCamera->getOrthoMode()) {
+		CoreServices::getInstance()->getRenderer()->setPerspectiveMode();
+	}
+	
 }
 
 
@@ -164,23 +172,23 @@ void GenericScene::loadScene(String fileName) {
 		return;
 	}
 	
-	float r,g,b,a;
+	Number r,g,b,a;
 	
-	OSBasics::read(&r, sizeof(float), 1, inFile);
-	OSBasics::read(&g, sizeof(float), 1, inFile);
-	OSBasics::read(&b, sizeof(float), 1, inFile);
+	OSBasics::read(&r, sizeof(Number), 1, inFile);
+	OSBasics::read(&g, sizeof(Number), 1, inFile);
+	OSBasics::read(&b, sizeof(Number), 1, inFile);
 	clearColor.setColor(r,g,b,1.0f);
 
-	OSBasics::read(&r, sizeof(float), 1, inFile);
-	OSBasics::read(&g, sizeof(float), 1, inFile);
-	OSBasics::read(&b, sizeof(float), 1, inFile);
+	OSBasics::read(&r, sizeof(Number), 1, inFile);
+	OSBasics::read(&g, sizeof(Number), 1, inFile);
+	OSBasics::read(&b, sizeof(Number), 1, inFile);
 	ambientColor.setColor(r,g,b,1.0f);
 	
 	
 	unsigned int numObjects, objectType,namelen;
 	char buffer[1024];
 	char flag;
-	float t[3],rq[4];
+	Number t[3],rq[4];
 	SceneEntity *newEntity;
 	
 	unsigned int lightmapIndex = 0;
@@ -194,8 +202,8 @@ void GenericScene::loadScene(String fileName) {
 	Logger::log("Loading scene (%d objects)\n", numObjects);
 	for(int i=0; i < numObjects; i++) {
 		
-		OSBasics::read(t, sizeof(float), 3, inFile);
-		OSBasics::read(rq, sizeof(float), 4, inFile);
+		OSBasics::read(t, sizeof(Number), 3, inFile);
+		OSBasics::read(rq, sizeof(Number), 4, inFile);
 		newEntity = NULL;
 		
 		OSBasics::read(&objectType, sizeof(unsigned int), 1, inFile);
@@ -220,10 +228,10 @@ void GenericScene::loadScene(String fileName) {
 				
 				Logger::log("adding mesh (texture: %s)\n", buffer);
 				
-				OSBasics::read(&r, sizeof(float), 1, inFile);
-				OSBasics::read(&g, sizeof(float), 1, inFile);
-				OSBasics::read(&b, sizeof(float), 1, inFile);
-				OSBasics::read(&a, sizeof(float), 1, inFile);
+				OSBasics::read(&r, sizeof(Number), 1, inFile);
+				OSBasics::read(&g, sizeof(Number), 1, inFile);
+				OSBasics::read(&b, sizeof(Number), 1, inFile);
+				OSBasics::read(&a, sizeof(Number), 1, inFile);
 				
 				newMaterial = (Material*) CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_MATERIAL, buffer);
 				newMesh = new Mesh(Mesh::TRI_MESH);
@@ -249,14 +257,14 @@ void GenericScene::loadScene(String fileName) {
 				} break;
 				case ENTITY_COLLMESH: {
 					unsigned int collType,numVertices,numFaces;
-					float co[3];
+					Number co[3];
 					OSBasics::read(&collType, sizeof(unsigned int), 1, inFile);
 					OSBasics::read(&numVertices, sizeof(unsigned int), 1, inFile);
 
 					Mesh *mesh = new Mesh(Mesh::TRI_MESH);
 					
 					for(int i=0; i < numVertices; i++) {
-						OSBasics::read(co, sizeof(float), 3, inFile);
+						OSBasics::read(co, sizeof(Number), 3, inFile);
 						Vertex *newVert = new Vertex(co[0], co[1], co[2]);
 						mesh->addVertex(newVert);
 					}
@@ -289,12 +297,12 @@ void GenericScene::loadScene(String fileName) {
 				break;
 				case ENTITY_LIGHT:
 				
-				float col[3],e,d;
+				Number col[3],e,d;
 				unsigned int lType;
 				OSBasics::read(&lType, sizeof(unsigned int), 1, inFile);				
-				OSBasics::read(&e, sizeof(float), 1, inFile);
-				OSBasics::read(&d, sizeof(float), 1, inFile);
-				OSBasics::read(col, sizeof(float), 3, inFile);
+				OSBasics::read(&e, sizeof(Number), 1, inFile);
+				OSBasics::read(&d, sizeof(Number), 1, inFile);
+				OSBasics::read(col, sizeof(Number), 3, inFile);
 
 				SceneLight *newLight = new SceneLight(lType, e, d, this);
 				newLight->lightColor.setColor(col[0],col[1],col[2],1.0f);
@@ -381,7 +389,7 @@ SceneEntity *GenericScene::getCustomEntityByType(String type) {
 }
 
 void GenericScene::writeEntityMatrix(SceneEntity *entity, OSFILE *outFile) {
-	float t[3],rq[4];
+	Number t[3],rq[4];
 	t[0] = entity->getPosition()->x;
 	t[1] = entity->getPosition()->y;
 	t[2] = entity->getPosition()->z;
@@ -391,8 +399,8 @@ void GenericScene::writeEntityMatrix(SceneEntity *entity, OSFILE *outFile) {
 	rq[2] = entity->getRotationQuat().y;
 	rq[3] = entity->getRotationQuat().z;						
 	
-	OSBasics::write(t, sizeof(float), 3, outFile);
-	OSBasics::write(rq, sizeof(float), 4, outFile);
+	OSBasics::write(t, sizeof(Number), 3, outFile);
+	OSBasics::write(rq, sizeof(Number), 4, outFile);
 	
 }
 
@@ -446,13 +454,13 @@ void GenericScene::saveScene(String fileName) {
 		
 		unsigned int numVertices = mesh->getMesh()->getNumVertices();
 		OSBasics::write(&numVertices, sizeof(unsigned int), 1, outFile);
-		float pos[3];
+		Number pos[3];
 		for(int j=0; j < numVertices; j++) {
 			Vertex *vert = mesh->getMesh()->getVertex(j);
 			pos[0] = vert->x;
 			pos[1] = vert->y;
 			pos[2] = vert->z;			
-			OSBasics::write(pos, sizeof(float),3, outFile);
+			OSBasics::write(pos, sizeof(Number),3, outFile);
 		}
 
 		unsigned int numFaces = mesh->getMesh()->getPolygonCount();
@@ -467,7 +475,7 @@ void GenericScene::saveScene(String fileName) {
 		}
 	}
 	
-	float col[3],e,d;
+	Number col[3],e,d;
 	for(int i=0; i < lights.size(); i++) {
 	
 		writeEntityMatrix(lights[i], outFile);
@@ -480,9 +488,9 @@ void GenericScene::saveScene(String fileName) {
 		e = lights[i]->getIntensity();
 		d = lights[i]->getDistance();
 		
-		OSBasics::write(&e, sizeof(float), 1, outFile);
-		OSBasics::write(&d, sizeof(float), 1, outFile);
-		OSBasics::write(col, sizeof(float), 3, outFile);
+		OSBasics::write(&e, sizeof(Number), 1, outFile);
+		OSBasics::write(&d, sizeof(Number), 1, outFile);
+		OSBasics::write(col, sizeof(Number), 3, outFile);
 	}
 
 	for(int i=0; i < customEntities.size(); i++) {
@@ -549,7 +557,7 @@ SceneLight *GenericScene::getLight(int index) {
 	return lights[index];
 }
 
-void GenericScene::generateLightmaps(float lightMapRes, float lightMapQuality, int numRadPasses) {
+void GenericScene::generateLightmaps(Number lightMapRes, Number lightMapQuality, int numRadPasses) {
 /*	
 	packer = new LightmapPacker(this);
 	packer->generateTextures(lightMapRes, lightMapQuality);

Core/Contents/Source/PolyImage.cpp

@@ -110,10 +110,10 @@ void Image::perlinNoise(int seed, bool alpha) {
 	Perlin *perlin = new Perlin(12,33,1,seed);
 	unsigned int *imageData32 = (unsigned int*)imageData;
 	Color pixelColor;
-	float noiseVal;
+	Number noiseVal;
 	
 	for(int i=0; i < width*height;i++) {
-			noiseVal = fabs(1.0f/perlin->Get( 0.1+(0.9f/((float)width)) * (i%width), (1.0f/((float)height)) *   (i - (i%width))));
+			noiseVal = fabs(1.0f/perlin->Get( 0.1+(0.9f/((Number)width)) * (i%width), (1.0f/((Number)height)) *   (i - (i%width))));
 			if(alpha)
 				pixelColor.setColor(noiseVal, noiseVal, noiseVal, noiseVal);
 			else
@@ -181,7 +181,7 @@ void Image::lineTo(int x, int y, Color col) {
 	line(brushPosX, brushPosY, brushPosX+x, brushPosY+y, col);
 }
 
-void Image::setPixel(int x, int y, float r, float g, float b, float a) {
+void Image::setPixel(int x, int y, Number r, Number g, Number b, Number a) {
 	if(x < 0 || x > width || y < 0 || y > height)
 		return;
 
@@ -191,7 +191,7 @@ void Image::setPixel(int x, int y, float r, float g, float b, float a) {
 	imageData32[x+(y*width)] = color.getUint();
 }
 
-void Image::multiply(float amt, bool color, bool alpha) {
+void Image::multiply(Number amt, bool color, bool alpha) {
 	int startIndex = 0;
 	int endIndex = 3;
 	if(!color)
@@ -201,17 +201,17 @@ void Image::multiply(float amt, bool color, bool alpha) {
 		
 	for (int i = 0; i < height*width*pixelSize; i+=pixelSize) {
 		for(int j = startIndex; j < endIndex+1;j++) {
-			if(((float)imageData[i+j]) * amt< 0)
+			if(((Number)imageData[i+j]) * amt< 0)
 				imageData[i+j] = 0;
-			else if(((float)imageData[i+j]) * amt > 255)
+			else if(((Number)imageData[i+j]) * amt > 255)
 				imageData[i+j] = 255;
 			else
-				imageData[i+j] = (char)(((float)imageData[i+j]) * amt);
+				imageData[i+j] = (char)(((Number)imageData[i+j]) * amt);
 		}
 	}
 }
 
-void Image::darken(float amt, bool color, bool alpha) {
+void Image::darken(Number amt, bool color, bool alpha) {
 	char decAmt = 255.0f * amt;
 	int startIndex = 0;
 	int endIndex = 3;
@@ -230,7 +230,7 @@ void Image::darken(float amt, bool color, bool alpha) {
 	}
 }
 
-void Image::lighten(float amt, bool color, bool alpha) {
+void Image::lighten(Number amt, bool color, bool alpha) {
 	char decAmt = 255.0f * amt;
 	int startIndex = 0;
 	int endIndex = 3;
@@ -414,9 +414,9 @@ void Image::line(int x0, int y0, int x1, int y1, Color col) {
 	
 	int deltax = x1 - x0;
 	int deltay = abs(y1 - y0);
-	float error = 0;
+	Number error = 0;
 
-     float deltaerr = ((float)deltay) / ((float)deltax);
+     Number deltaerr = ((Number)deltay) / ((Number)deltax);
      int ystep;
      int y = y0;
      if(y0 < y1)
@@ -430,7 +430,7 @@ void Image::line(int x0, int y0, int x1, int y1, Color col) {
 		} else {
 			setPixel(x,y,col);
 		}
-         error = error + ((float)deltaerr);
+         error = error + ((Number)deltaerr);
          if(error >= 0.5) {
              y = y + ystep;
              error = error - 1.0;
@@ -438,7 +438,7 @@ void Image::line(int x0, int y0, int x1, int y1, Color col) {
 	}
 }
 
-void Image::fill(float r, float g, float b, float a) {
+void Image::fill(Number r, Number g, Number b, Number a) {
 	Color *color = new Color(r,g,b,a);
 	unsigned int val = color->getUint();
 	unsigned int *imageData32 = (unsigned int*) imageData;

Core/Contents/Source/PolyLabel.cpp

@@ -104,11 +104,11 @@ int Label::getTextHeight(Font *font, String text, int size) {
 	return height;
 }
 
-float Label::getTextWidth() {
+Number Label::getTextWidth() {
 	return currentTextWidth;
 }
 
-float Label::getTextHeight() {
+Number Label::getTextHeight() {
 	return currentTextHeight;
 }
 

Core/Contents/Source/PolyMaterialManager.cpp

@@ -61,7 +61,7 @@ void MaterialManager::addShaderModule(PolycodeShaderModule *module) {
 	shaderModules.push_back(module);
 }
 
-Texture *MaterialManager::createTextureFromFile(String fileName) {
+Texture *MaterialManager::createTextureFromFile(String fileName, bool clamp) {
 	Texture *newTexture;
 	newTexture = getTextureByResourcePath(fileName);
 	if(newTexture) {
@@ -70,7 +70,7 @@ Texture *MaterialManager::createTextureFromFile(String fileName) {
 	
 	Image *image = new Image(fileName);
 	if(image->isLoaded()) {
-		newTexture = createTexture(image->getWidth(), image->getHeight(), image->getPixels(), true);
+		newTexture = createTexture(image->getWidth(), image->getHeight(), image->getPixels(), clamp);
 	} else {
 		char *data = (char*)malloc(4);
 		newTexture = createTexture(1, 1, data, true);
@@ -224,8 +224,8 @@ Material *MaterialManager::materialFromXMLNode(TiXmlNode *node) {
 								if(newTarget->height > 1.0f)
 									newTarget->height = 1.0f;
 									
-								newTarget->width = ((float)CoreServices::getInstance()->getRenderer()->getXRes()) * newTarget->width;
-								newTarget->height = ((float)CoreServices::getInstance()->getRenderer()->getYRes()) * newTarget->height;
+								newTarget->width = ((Number)CoreServices::getInstance()->getRenderer()->getXRes()) * newTarget->width;
+								newTarget->height = ((Number)CoreServices::getInstance()->getRenderer()->getYRes()) * newTarget->height;
 							}						
 						}
 					}						

Core/Contents/Source/PolyMatrix4.cpp

@@ -16,7 +16,7 @@ Matrix4::Matrix4() {
 }
 
 void Matrix4::init() {
-	memset(ml, 0, sizeof(float)*16);
+	memset(ml, 0, sizeof(Number)*16);
 	ml[0] = 1;
 	ml[5] = 1;
 	ml[10] = 1;
@@ -27,40 +27,40 @@ Matrix4::~Matrix4() {
 
 }
 
-Matrix4::Matrix4(float *m) {
-	memcpy(ml, m, sizeof(float)*16);
+Matrix4::Matrix4(Number *m) {
+	memcpy(ml, m, sizeof(Number)*16);
 }
 
     Matrix4 Matrix4::inverse() 
     {
-        float m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
-        float m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
-        float m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
-        float m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
-
-        float v0 = m20 * m31 - m21 * m30;
-        float v1 = m20 * m32 - m22 * m30;
-        float v2 = m20 * m33 - m23 * m30;
-        float v3 = m21 * m32 - m22 * m31;
-        float v4 = m21 * m33 - m23 * m31;
-        float v5 = m22 * m33 - m23 * m32;
-
-        float t00 = + (v5 * m11 - v4 * m12 + v3 * m13);
-        float t10 = - (v5 * m10 - v2 * m12 + v1 * m13);
-        float t20 = + (v4 * m10 - v2 * m11 + v0 * m13);
-        float t30 = - (v3 * m10 - v1 * m11 + v0 * m12);
-
-        float invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
-
-        float d00 = t00 * invDet;
-        float d10 = t10 * invDet;
-        float d20 = t20 * invDet;
-        float d30 = t30 * invDet;
-
-        float d01 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
-        float d11 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
-        float d21 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
-        float d31 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+        Number m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
+        Number m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
+        Number m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
+        Number m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
+
+        Number v0 = m20 * m31 - m21 * m30;
+        Number v1 = m20 * m32 - m22 * m30;
+        Number v2 = m20 * m33 - m23 * m30;
+        Number v3 = m21 * m32 - m22 * m31;
+        Number v4 = m21 * m33 - m23 * m31;
+        Number v5 = m22 * m33 - m23 * m32;
+
+        Number t00 = + (v5 * m11 - v4 * m12 + v3 * m13);
+        Number t10 = - (v5 * m10 - v2 * m12 + v1 * m13);
+        Number t20 = + (v4 * m10 - v2 * m11 + v0 * m13);
+        Number t30 = - (v3 * m10 - v1 * m11 + v0 * m12);
+
+        Number invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
+
+        Number d00 = t00 * invDet;
+        Number d10 = t10 * invDet;
+        Number d20 = t20 * invDet;
+        Number d30 = t30 * invDet;
+
+        Number d01 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+        Number d11 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+        Number d21 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+        Number d31 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
 
         v0 = m10 * m31 - m11 * m30;
         v1 = m10 * m32 - m12 * m30;
@@ -69,10 +69,10 @@ Matrix4::Matrix4(float *m) {
         v4 = m11 * m33 - m13 * m31;
         v5 = m12 * m33 - m13 * m32;
 
-        float d02 = + (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
-        float d12 = - (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
-        float d22 = + (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
-        float d32 = - (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+        Number d02 = + (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+        Number d12 = - (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+        Number d22 = + (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+        Number d32 = - (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
 
         v0 = m21 * m10 - m20 * m11;
         v1 = m22 * m10 - m20 * m12;
@@ -81,10 +81,10 @@ Matrix4::Matrix4(float *m) {
         v4 = m23 * m11 - m21 * m13;
         v5 = m23 * m12 - m22 * m13;
 
-        float d03 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
-        float d13 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
-        float d23 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
-        float d33 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+        Number d03 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+        Number d13 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+        Number d23 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+        Number d33 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
 
         return Matrix4(
             d00, d01, d02, d03,
@@ -96,38 +96,38 @@ Matrix4::Matrix4(float *m) {
     Matrix4 Matrix4::inverseAffine(void) 
     {
 
-        float m10 = m[1][0], m11 = m[1][1], m12 = m[1][2];
-        float m20 = m[2][0], m21 = m[2][1], m22 = m[2][2];
+        Number m10 = m[1][0], m11 = m[1][1], m12 = m[1][2];
+        Number m20 = m[2][0], m21 = m[2][1], m22 = m[2][2];
 
-        float t00 = m22 * m11 - m21 * m12;
-        float t10 = m20 * m12 - m22 * m10;
-        float t20 = m21 * m10 - m20 * m11;
+        Number t00 = m22 * m11 - m21 * m12;
+        Number t10 = m20 * m12 - m22 * m10;
+        Number t20 = m21 * m10 - m20 * m11;
 
-        float m00 = m[0][0], m01 = m[0][1], m02 = m[0][2];
+        Number m00 = m[0][0], m01 = m[0][1], m02 = m[0][2];
 
-        float invDet = 1 / (m00 * t00 + m01 * t10 + m02 * t20);
+        Number invDet = 1 / (m00 * t00 + m01 * t10 + m02 * t20);
 
         t00 *= invDet; t10 *= invDet; t20 *= invDet;
 
         m00 *= invDet; m01 *= invDet; m02 *= invDet;
 
-        float r00 = t00;
-        float r01 = m02 * m21 - m01 * m22;
-        float r02 = m01 * m12 - m02 * m11;
+        Number r00 = t00;
+        Number r01 = m02 * m21 - m01 * m22;
+        Number r02 = m01 * m12 - m02 * m11;
 
-        float r10 = t10;
-        float r11 = m00 * m22 - m02 * m20;
-        float r12 = m02 * m10 - m00 * m12;
+        Number r10 = t10;
+        Number r11 = m00 * m22 - m02 * m20;
+        Number r12 = m02 * m10 - m00 * m12;
 
-        float r20 = t20;
-        float r21 = m01 * m20 - m00 * m21;
-        float r22 = m00 * m11 - m01 * m10;
+        Number r20 = t20;
+        Number r21 = m01 * m20 - m00 * m21;
+        Number r22 = m00 * m11 - m01 * m10;
 
-        float m03 = m[0][3], m13 = m[1][3], m23 = m[2][3];
+        Number m03 = m[0][3], m13 = m[1][3], m23 = m[2][3];
 
-        float r03 = - (r00 * m03 + r01 * m13 + r02 * m23);
-        float r13 = - (r10 * m03 + r11 * m13 + r12 * m23);
-        float r23 = - (r20 * m03 + r21 * m13 + r22 * m23);
+        Number r03 = - (r00 * m03 + r01 * m13 + r02 * m23);
+        Number r13 = - (r10 * m03 + r11 * m13 + r12 * m23);
+        Number r23 = - (r20 * m03 + r21 * m13 + r22 * m23);
 
         return Matrix4(
             r00, r01, r02, r03,

Core/Contents/Source/PolyMesh.cpp

@@ -25,7 +25,7 @@ namespace Polycode {
 		loadMesh(fileName);
 		vertexBuffer = NULL;			
 		useVertexColors = false;
-			}
+	}
 	
 	Mesh::Mesh(int meshType) {
 		for(int i=0; i < 16; i++) {
@@ -49,7 +49,15 @@ namespace Polycode {
 			delete polygons[i];
 		}
 		polygons.clear();
-		delete vertexBuffer;
+		if(vertexBuffer)
+			delete vertexBuffer;
+		
+		for(int i=0; i < 16; i++) {
+			if(renderDataArrays[i]) {
+				free(renderDataArrays[i]->arrayPtr);
+				delete renderDataArrays[i];
+			}
+		}
 	}
 	
 	VertexBuffer *Mesh::getVertexBuffer() {
@@ -61,9 +69,9 @@ namespace Polycode {
 		meshHasVertexBuffer = true;
 	}
 	
-	float Mesh::getRadius() {
-		float hRad = 0;
-		float len;
+	Number Mesh::getRadius() {
+		Number hRad = 0;
+		Number len;
 		for(int i=0; i < vertices.size(); i++) {
 			len = vertices[i]->length();
 			if(len > hRad)
@@ -72,59 +80,52 @@ namespace Polycode {
 		return hRad;
 	}
 	
-	void Mesh::saveToFile(OSFILE *outFile) {
-		unsigned int numVertices = vertices.size();
-		OSBasics::write(&numUVs, sizeof(unsigned int), 1, outFile);		
-		OSBasics::write(&numVertices, sizeof(unsigned int), 1, outFile);
-
-		Vector3_struct pos;
-		Vector3_struct nor;
-		
-		for(int i=0; i < vertices.size(); i++) {
-			pos.x = vertices[i]->x;
-			pos.y = vertices[i]->y;
-			pos.z = vertices[i]->z;			
-
-			nor.x = vertices[i]->normal->x;
-			nor.y = vertices[i]->normal->y;
-			nor.z = vertices[i]->normal->z;
+	void Mesh::saveToFile(OSFILE *outFile) {				
+		unsigned int numFaces = polygons.size();
 
-			OSBasics::write(&pos, sizeof(Vector3_struct), 1, outFile);
-			OSBasics::write(&nor, sizeof(Vector3_struct), 1, outFile);
+		OSBasics::write(&meshType, sizeof(unsigned int), 1, outFile);		
+		OSBasics::write(&numFaces, sizeof(unsigned int), 1, outFile);
+		for(int i=0; i < polygons.size(); i++) {
+			
+			Vector3_struct pos;
+			Vector3_struct nor;
+			Vector4_struct col;			
+			Vector2_struct tex;
 			
-			unsigned int hasWeights = 0;
-			OSBasics::write(&hasWeights, sizeof(unsigned int), 1, outFile);
+			for(int j=0; j <  polygons[i]->getVertexCount(); j++) {
+				
+				pos.x =  polygons[i]->getVertex(j)->x;
+				pos.y =  polygons[i]->getVertex(j)->y;
+				pos.z =  polygons[i]->getVertex(j)->z;
 
-		}
+				nor.x =  polygons[i]->getVertex(j)->normal->x;
+				nor.y =  polygons[i]->getVertex(j)->normal->y;
+				nor.z =  polygons[i]->getVertex(j)->normal->z;
 
-		unsigned int numFaces = polygons.size();
-		OSBasics::write(&numFaces, sizeof(unsigned int), 1, outFile);
-		
-		Face_struct poly;
-		for(int i=0; i < polygons.size(); i++) {
-			poly.nx = polygons[i]->getFaceNormal().x;
-			poly.ny = polygons[i]->getFaceNormal().y;
-			poly.nz = polygons[i]->getFaceNormal().z;			
-			poly.v1 = getVertexIndex(polygons[i]->getVertex(0));
-			poly.v2 = getVertexIndex(polygons[i]->getVertex(1));
-			poly.v3 = getVertexIndex(polygons[i]->getVertex(2));			
-			poly.uvs[0].x = polygons[i]->getTexCoord(0)->x;
-			poly.uvs[0].y = polygons[i]->getTexCoord(0)->y;
-			poly.uvs[1].x = polygons[i]->getTexCoord(1)->x;
-			poly.uvs[1].y = polygons[i]->getTexCoord(1)->y;
-			poly.uvs[2].x = polygons[i]->getTexCoord(2)->x;
-			poly.uvs[2].y = polygons[i]->getTexCoord(2)->y;
-			OSBasics::write(&poly, sizeof(Face_struct), 1, outFile);
-			if(numUVs == 2) {
-				Vector2_struct uv2s[3];
-				uv2s[0].x = polygons[i]->getTexCoord2(0)->x;
-				uv2s[0].y = polygons[i]->getTexCoord2(0)->y;
-				uv2s[1].x = polygons[i]->getTexCoord2(1)->x;
-				uv2s[1].y = polygons[i]->getTexCoord2(1)->y;
-				uv2s[2].x = polygons[i]->getTexCoord2(2)->x;
-				uv2s[2].y = polygons[i]->getTexCoord2(2)->y;
-				OSBasics::write(uv2s, sizeof(Vector2_struct), 3, outFile);			
+				col.x =  polygons[i]->getVertex(j)->vertexColor.r;
+				col.y =  polygons[i]->getVertex(j)->vertexColor.g;
+				col.z =  polygons[i]->getVertex(j)->vertexColor.b;
+				col.w =  polygons[i]->getVertex(j)->vertexColor.a;
+				
+				tex.x = polygons[i]->getVertex(j)->getTexCoord()->x;
+				tex.y = polygons[i]->getVertex(j)->getTexCoord()->y;
+				
+				OSBasics::write(&pos, sizeof(Vector3_struct), 1, outFile);
+				OSBasics::write(&nor, sizeof(Vector3_struct), 1, outFile);
+				OSBasics::write(&col, sizeof(Vector4_struct), 1, outFile);				
+				OSBasics::write(&tex, sizeof(Vector2_struct), 1, outFile);								
+				
+				unsigned int numBoneWeights = polygons[i]->getVertex(j)->getNumBoneAssignments();
+				OSBasics::write(&numBoneWeights, sizeof(unsigned int), 1, outFile);					
+				for(int b=0; b < numBoneWeights; b++) {
+					BoneAssignment *a = polygons[i]->getVertex(j)->getBoneAssignment(b);
+					unsigned int boneID = a->boneID;
+					float weight = a->weight;
+					OSBasics::write(&boneID, sizeof(unsigned int), 1, outFile);
+					OSBasics::write(&weight, sizeof(float), 1, outFile);												
+				}
 			}
+			
 		}
 	}
 
@@ -137,71 +138,131 @@ namespace Polycode {
 	}
 	
 	void Mesh::loadFromFile(OSFILE *inFile) {
-		int i;
+
+		unsigned int meshType;		
+		OSBasics::read(&meshType, sizeof(unsigned int), 1, inFile);				
+		setMeshType(meshType);
 		
-		Vertex *newVertex;
-		Polygon *polygon;
-		unsigned int numVertices, numFaces, hasWeights, numWeights, numUVs;
+		int verticesPerFace;
+		switch(meshType) {
+			case TRI_MESH:
+				verticesPerFace = 3;
+			break;
+			case QUAD_MESH:
+				verticesPerFace = 4;
+			break;
+			default:
+				verticesPerFace = 1;				
+			break;
+		}
 		
-		unsigned int boneID;
-		float boneWeight;
+		unsigned int numFaces;		
+		OSBasics::read(&numFaces, sizeof(unsigned int), 1, inFile);
 		
-		OSBasics::read(&numUVs, sizeof(unsigned int), 1, inFile);
-		OSBasics::read(&numVertices, sizeof(unsigned int), 1, inFile);
 		Vector3_struct pos;
 		Vector3_struct nor;
-		Face_struct face;
+		Vector4_struct col;			
+		Vector2_struct tex;
 		
-		for(i=0; i<numVertices; i++) {
-			OSBasics::read(&pos, sizeof(Vector3_struct), 1, inFile);
-			OSBasics::read(&nor, sizeof(Vector3_struct), 1, inFile);
-			
-			newVertex = new Vertex(pos.x, pos.y, pos.z, nor.x, nor.y,nor.z);
+		for(int i=0; i < numFaces; i++) {	
+			Polygon *poly = new Polygon();			
 			
-			OSBasics::read(&hasWeights, sizeof(unsigned int), 1, inFile);
-			if(hasWeights == 1) {
-					OSBasics::read(&numWeights, sizeof(unsigned int), 1, inFile);
-					for(int j=0; j < numWeights; j++) {
-						OSBasics::read(&boneID, sizeof(unsigned int), 1, inFile);
-						OSBasics::read(&boneWeight, sizeof(float), 1, inFile);
-						newVertex->addBoneAssignment(boneID, boneWeight);
-					}
-					newVertex->normalizeWeights();
+			for(int j=0; j < verticesPerFace; j++) {
+				OSBasics::read(&pos, sizeof(Vector3_struct), 1, inFile);
+				OSBasics::read(&nor, sizeof(Vector3_struct), 1, inFile);
+				OSBasics::read(&col, sizeof(Vector4_struct), 1, inFile);						
+				OSBasics::read(&tex, sizeof(Vector2_struct), 1, inFile);						
+				
+				Vertex *vertex = new Vertex(pos.x, pos.y, pos.z);
+				vertex->setNormal(nor.x,nor.y, nor.z);
+				vertex->restNormal.set(nor.x,nor.y, nor.z);
+				vertex->vertexColor.setColor(col.x,col.y, col.z, col.w);
+				vertex->setTexCoord(tex.x, tex.y);
+				
+				unsigned int numBoneWeights;
+				OSBasics::read(&numBoneWeights, sizeof(unsigned int), 1, inFile);								
+				for(int b=0; b < numBoneWeights; b++) {
+					float weight;
+					unsigned int boneID;
+					OSBasics::read(&boneID, sizeof(unsigned int), 1, inFile);													
+					OSBasics::read(&weight, sizeof(float), 1, inFile);																		
+					vertex->addBoneAssignment(boneID, weight);
+				}
+				
+				
+				
+				poly->addVertex(vertex);
 			}
-			vertices.push_back(newVertex);
+			addPolygon(poly);
 		}
 		
-		OSBasics::read(&numFaces, sizeof(unsigned int), 1, inFile);
+		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+		arrayDirtyMap[RenderDataArray::COLOR_DATA_ARRAY] = true;				
+		arrayDirtyMap[RenderDataArray::TEXCOORD_DATA_ARRAY] = true;						
+		arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;										
 		
-		for(i=0; i<numFaces; i++) {
-			OSBasics::read(&face, sizeof(Face_struct), 1, inFile);
-			polygon = new Polygon();
-			polygon->addVertex(vertices[face.v1]);
-			polygon->addVertex(vertices[face.v2]);
-			polygon->addVertex(vertices[face.v3]);
-			
-			polygon->setNormal(Vector3(face.nx,face.ny,face.nz));
-			
-			vertices[face.v1]->setTexCoord(face.uvs[0].x,face.uvs[0].y);
-			vertices[face.v2]->setTexCoord(face.uvs[1].x,face.uvs[1].y);
-			vertices[face.v3]->setTexCoord(face.uvs[2].x,face.uvs[2].y);
-			
-			polygon->addTexCoord(face.uvs[0].x,face.uvs[0].y);
-			polygon->addTexCoord(face.uvs[1].x,face.uvs[1].y);
-			polygon->addTexCoord(face.uvs[2].x,face.uvs[2].y);	
-			polygon->setUseFaceUV(true);
-			
-			if(numUVs == 2) {
-				Vector2_struct uv2s[3];
-				OSBasics::read(uv2s, sizeof(Vector2_struct), 3, inFile);
-				polygon->addTexCoord2(uv2s[0].x,uv2s[0].y);
-				polygon->addTexCoord2(uv2s[1].x,uv2s[1].y);
-				polygon->addTexCoord2(uv2s[2].x,uv2s[2].y);	
-			}
-			
-			polygons.push_back(polygon);
-		}
-		this->numUVs = numUVs;				
+		
+//		int i;
+//		
+//		Vertex *newVertex;
+//		Polygon *polygon;
+//		unsigned int numVertices, numFaces, hasWeights, numWeights, numUVs;
+//		
+//		unsigned int boneID;
+//		Number boneWeight;
+//		
+//		OSBasics::read(&numUVs, sizeof(unsigned int), 1, inFile);
+//		OSBasics::read(&numVertices, sizeof(unsigned int), 1, inFile);
+//		Vector3_struct pos;
+//		Vector3_struct nor;
+//		Face_struct face;
+//		
+//		for(i=0; i<numVertices; i++) {
+//			OSBasics::read(&pos, sizeof(Vector3_struct), 1, inFile);
+//			OSBasics::read(&nor, sizeof(Vector3_struct), 1, inFile);
+//			
+//			newVertex = new Vertex(pos.x, pos.y, pos.z, nor.x, nor.y,nor.z);
+//			
+//			OSBasics::read(&hasWeights, sizeof(unsigned int), 1, inFile);
+//			if(hasWeights == 1) {
+//					OSBasics::read(&numWeights, sizeof(unsigned int), 1, inFile);
+//					for(int j=0; j < numWeights; j++) {
+//						OSBasics::read(&boneID, sizeof(unsigned int), 1, inFile);
+//						OSBasics::read(&boneWeight, sizeof(Number), 1, inFile);
+//						newVertex->addBoneAssignment(boneID, boneWeight);
+//					}
+//					newVertex->normalizeWeights();
+//			}
+//			vertices.push_back(newVertex);
+//		}
+//		
+//		OSBasics::read(&numFaces, sizeof(unsigned int), 1, inFile);
+//		
+//		for(i=0; i<numFaces; i++) {
+//			OSBasics::read(&face, sizeof(Face_struct), 1, inFile);
+//			polygon = new Polygon();			
+//			polygon->setNormal(Vector3(face.nx,face.ny,face.nz));
+//			
+//			vertices[face.v1]->setTexCoord(face.uvs[0].x,face.uvs[0].y);
+//			vertices[face.v2]->setTexCoord(face.uvs[1].x,face.uvs[1].y);
+//			vertices[face.v3]->setTexCoord(face.uvs[2].x,face.uvs[2].y);
+//			
+//			polygon->addTexCoord(face.uvs[0].x,face.uvs[0].y);
+//			polygon->addTexCoord(face.uvs[1].x,face.uvs[1].y);
+//			polygon->addTexCoord(face.uvs[2].x,face.uvs[2].y);	
+//			polygon->setUseFaceUV(true);
+//			
+//			if(numUVs == 2) {
+//				Vector2_struct uv2s[3];
+//				OSBasics::read(uv2s, sizeof(Vector2_struct), 3, inFile);
+//				polygon->addTexCoord2(uv2s[0].x,uv2s[0].y);
+//				polygon->addTexCoord2(uv2s[1].x,uv2s[1].y);
+//				polygon->addTexCoord2(uv2s[2].x,uv2s[2].y);	
+//			}
+//			
+//			polygons.push_back(polygon);
+//		}
+//		this->numUVs = numUVs;				
 	}
 	
 	void Mesh::loadMesh(String fileName) {
@@ -218,12 +279,12 @@ namespace Polycode {
 		
 	}
 	
-	void Mesh::createPlane(float w, float h) { 
+	void Mesh::createPlane(Number w, Number h) { 
 		Polygon *imagePolygon = new Polygon();
-		imagePolygon->addVertex(0,0,0,0,0);
-		imagePolygon->addVertex(w,0,0, 1, 0);
-		imagePolygon->addVertex(w,h,0, 1, 1);
-		imagePolygon->addVertex(0,h,0,0,1);
+		imagePolygon->addVertex(0,0,0,0,1);
+		imagePolygon->addVertex(w,0,0, 1, 1);
+		imagePolygon->addVertex(w,h,0, 1, 0);
+		imagePolygon->addVertex(0,h,0,0,0);
 		addPolygon(imagePolygon);
 		
 		for(int i=0; i < polygons.size(); i++) {
@@ -257,14 +318,67 @@ namespace Polycode {
 		return vertices[index];
 	}
 	
+	Vector3 Mesh::recenterMesh() {
+		Vector3 positiveOffset;
+		Vector3 negativeOffset;
+		
+		for(int i=0; i < polygons.size(); i++) {
+			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
+				positiveOffset.x = max(positiveOffset.x,polygons[i]->getVertex(j)->x);
+				positiveOffset.y = max(positiveOffset.y,polygons[i]->getVertex(j)->y);
+				positiveOffset.z = max(positiveOffset.z,polygons[i]->getVertex(j)->z);							
+				
+			}
+		}
+		
+		for(int i=0; i < polygons.size(); i++) {
+			for(int j=0; j < polygons[i]->getVertexCount(); j++) {
+				negativeOffset.x = min(negativeOffset.x,polygons[i]->getVertex(j)->x);
+				negativeOffset.y = min(negativeOffset.y,polygons[i]->getVertex(j)->y);
+				negativeOffset.z = min(negativeOffset.z,polygons[i]->getVertex(j)->z);							
+				
+			}
+		}		
+		
+		Vector3 finalOffset;
+		
+		finalOffset.x = (positiveOffset.x + negativeOffset.x)/2.0f;
+		finalOffset.y = (positiveOffset.y + negativeOffset.y)/2.0f;
+		finalOffset.z = (positiveOffset.z + negativeOffset.z)/2.0f;		
+		
+		vector<Vertex*> done;
+		for(int i=0; i < polygons.size(); i++) {
+			for(int j=0; j < polygons[i]->getVertexCount(); j++) {	
+				
+				bool alreadyDone = false;
+				for(int k=0; k < done.size(); k++) {
+					if(done[k] == polygons[i]->getVertex(j))
+						alreadyDone = true;
+				}
+				
+				if(!alreadyDone) {
+					polygons[i]->getVertex(j)->x = polygons[i]->getVertex(j)->x - finalOffset.x;
+					polygons[i]->getVertex(j)->y = polygons[i]->getVertex(j)->y - finalOffset.y;
+					polygons[i]->getVertex(j)->z = polygons[i]->getVertex(j)->z - finalOffset.z;				
+					done.push_back(polygons[i]->getVertex(j));
+				}
+			}
+		}		
+	
+		
+		arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;
+		
+		return finalOffset;		
+	}	
+	
 	Vector3 Mesh::calculateBBox() {
 		Vector3 retVec;
 		
 		for(int i=0; i < polygons.size(); i++) {
 			for(int j=0; j < polygons[i]->getVertexCount(); j++) {				
-				retVec.x = max(retVec.x,fabsf(polygons[i]->getVertex(j)->x));
-				retVec.y = max(retVec.y,fabsf(polygons[i]->getVertex(j)->y));
-				retVec.z = max(retVec.z,fabsf(polygons[i]->getVertex(j)->z));							
+				retVec.x = max(retVec.x,fabs(polygons[i]->getVertex(j)->x));
+				retVec.y = max(retVec.y,fabs(polygons[i]->getVertex(j)->y));
+				retVec.z = max(retVec.z,fabs(polygons[i]->getVertex(j)->z));							
 				
 			}
 		}
@@ -272,20 +386,20 @@ namespace Polycode {
 		return retVec*2;
 	}
 	
-	void Mesh::createSphere(float radius, float numRings, float numSegments) {
+	void Mesh::createSphere(Number radius, Number numRings, Number numSegments) {
 
-		float fDeltaRingAngle = (PI / numRings);
-        float fDeltaSegAngle = (2 * PI / numSegments);
+		Number fDeltaRingAngle = (PI / numRings);
+        Number fDeltaSegAngle = (2 * PI / numSegments);
 		
 		for(int i=0; i < numRings; i++) {
-			float r0 = radius * sinf (i * fDeltaRingAngle);
-			float y0 = radius * cosf (i * fDeltaRingAngle);			
+			Number r0 = radius * sinf (i * fDeltaRingAngle);
+			Number y0 = radius * cosf (i * fDeltaRingAngle);			
 			for(int j=0; j < numSegments; j++) {
-				float x0 = r0 * sinf(j * fDeltaSegAngle);
-				float z0 = r0 * cosf(j * fDeltaSegAngle);
+				Number x0 = r0 * sinf(j * fDeltaSegAngle);
+				Number z0 = r0 * cosf(j * fDeltaSegAngle);
 				
-				float tx0 = (float) j / (float) numSegments;
-				float tx1 = (float) i / (float) numRings;
+				Number tx0 = (Number) j / (Number) numSegments;
+				Number tx1 = (Number) i / (Number) numRings;
 				
 				Vector3 nor = Vector3(x0, y0, z0);
 				nor.Normalize();
@@ -302,7 +416,7 @@ namespace Polycode {
 		
 	}
 
-	void Mesh::createBox(float w, float d, float h) {
+	void Mesh::createBox(Number w, Number d, Number h) {
 		Polygon *polygon = new Polygon();
 		polygon->addVertex(w,0,h, 1, 1);
 		polygon->addVertex(0,0,h, 1, 0);

Core/Contents/Source/PolyObject.cpp

@@ -40,7 +40,7 @@ TiXmlElement *Object::createElementFromObjectEntry(ObjectEntry *entry) {
 					newElement->SetAttribute(childEntry->name.c_str(), "false");
 			break;
 			case ObjectEntry::FLOAT_ENTRY:
-				newElement->SetAttribute(childEntry->name.c_str(), String::floatToString(childEntry->floatVal).c_str());								
+				newElement->SetAttribute(childEntry->name.c_str(), String::NumberToString(childEntry->NumberVal).c_str());								
 			break;
 			case ObjectEntry::INT_ENTRY:				
 				newElement->SetAttribute(childEntry->name.c_str(), childEntry->intVal);												
@@ -98,7 +98,7 @@ void Object::createFromXMLElement(TiXmlElement *element, ObjectEntry *entry) {
 		if (pAttrib->QueryIntValue(&ival)==TIXML_SUCCESS) {
 			
 			if(newEntry->stringVal.find(".") != -1 && pAttrib->QueryDoubleValue(&dval)==TIXML_SUCCESS) {
-				newEntry->floatVal = dval;
+				newEntry->NumberVal = dval;
 				newEntry->type = ObjectEntry::FLOAT_ENTRY;				
 			} else {
 				newEntry->intVal = ival;

Core/Contents/Source/PolyParticle.cpp

@@ -16,21 +16,23 @@ Particle::Particle(int particleType, bool isScreenParticle, Material *material,
 	if(isScreenParticle) {
 		createScreenParticle(particleType, texture, particleMesh);		
 	} else {
-		createSceneParticle(particleType, material, particleMesh);
+		createSceneParticle(particleType, texture, particleMesh);
 	}
 	
-	Reset();
+	Reset(true);
 }
 
-void Particle::createSceneParticle(int particleType, Material *material, Mesh *particleMesh) {
+void Particle::createSceneParticle(int particleType, Texture *texture, Mesh *particleMesh) {
 	switch(particleType) {
 		case BILLBOARD_PARTICLE:
 		{
 			ScenePrimitive *primitive = new ScenePrimitive(ScenePrimitive::TYPE_PLANE, 1.0f, 1.0f);
-			primitive->setMaterial(material);
+			primitive->setTexture(texture);
 			primitive->billboardMode = true;
 			primitive->billboardRoll = true;
-			primitive->setDepthWrite(false);
+//			primitive->alphaTest = true;
+//			primitive->depthTest = false;
+			primitive->depthWrite = false;
 			primitive->backfaceCulled = false;
 			particleBody = primitive;			
 		}
@@ -40,14 +42,17 @@ void Particle::createSceneParticle(int particleType, Material *material, Mesh *p
 			SceneMesh *primitive = new SceneMesh(particleMesh);
 			if(particleMesh->getMeshType() == Mesh::TRI_MESH)
 				primitive->cacheToVertexBuffer(true);
-			primitive->setMaterial(material);
+			primitive->setTexture(texture);
 			//			primitive->billboardMode = true;
 			//			primitive->billboardRoll = true;
 			//primitive->depthTest = false;
 			//			primitive->backfaceCulled = false;
 			particleBody = primitive;						
 		}			
-			break;
+		break;
+		default:
+			assert(0);
+		break;
 	}
 }
 
@@ -78,15 +83,19 @@ void Particle::createScreenParticle(int particleType, Texture *texture, Mesh *pa
 }
 
 
-void Particle::Reset() {
-	if(life > lifespan)
-		life = 0 + (life - lifespan);
-	else
-		life = 0;
+void Particle::Reset(bool continuious) {
+	if(continuious) {
+		if(life > lifespan)
+			life = 0 + (life - lifespan);
+		else
+			life = 0;
+	} else {
+			life = 0;		
+	}
 
-	perlinPosX = (float)rand()/RAND_MAX;
-	perlinPosY = (float)rand()/RAND_MAX;
-	perlinPosZ = (float)rand()/RAND_MAX;
+	perlinPosX = (Number)rand()/RAND_MAX;
+	perlinPosY = (Number)rand()/RAND_MAX;
+	perlinPosZ = (Number)rand()/RAND_MAX;
 	
 }
 

Core/Contents/Source/PolyParticleEmitter.cpp

@@ -11,8 +11,34 @@
 
 using namespace Polycode;
 
+SceneParticleEmitter::SceneParticleEmitter(String imageFile, Mesh *particleMesh, SceneMesh *emitter, Scene *particleParentScene, int particleType, int emitterType, Number lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation)
+: ParticleEmitter(imageFile, particleMesh, particleType, emitterType, lifespan, numParticles,  direction, gravity, deviation),
+SceneEntity()
+{
+	isScreenEmitter = false;
+	emitterMesh = emitter;	
+	this->particleParentScene = particleParentScene;	
+	createParticles();	
+}
+
+SceneParticleEmitter::~SceneParticleEmitter() {
+	
+}
+
+void SceneParticleEmitter::addParticleBody(Entity *particleBody) {
+	particleParentScene->addEntity((SceneEntity*)particleBody);	
+}
+
+Matrix4 SceneParticleEmitter::getBaseMatrix() {
+	return getConcatenatedMatrix();	
+}
+
+void SceneParticleEmitter::Update() {
+	updateEmitter();
+}
+
 
-ScreenParticleEmitter::ScreenParticleEmitter(String imageFile, Mesh *particleMesh, ScreenMesh *emitter, Screen *particleParentScreen, int particleType, int emitterType, float lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation) 
+ScreenParticleEmitter::ScreenParticleEmitter(String imageFile, Mesh *particleMesh, ScreenMesh *emitter, Screen *particleParentScreen, int particleType, int emitterType, Number lifespan, unsigned int numParticles, Vector3 direction, Vector3 gravity, Vector3 deviation) 
 : ParticleEmitter(imageFile, particleMesh, particleType, emitterType, lifespan, numParticles,  direction, gravity, deviation),
 ScreenEntity()
 {
@@ -38,7 +64,7 @@ Matrix4 ScreenParticleEmitter::getBaseMatrix() {
 	return getConcatenatedMatrix();
 }
 
-ParticleEmitter::ParticleEmitter(String imageFile, Mesh *particleMesh, int particleType, int emitterType, float lifespan, unsigned int numParticles,  Vector3 direction, Vector3 gravity, Vector3 deviation)  {
+ParticleEmitter::ParticleEmitter(String imageFile, Mesh *particleMesh, int particleType, int emitterType, Number lifespan, unsigned int numParticles,  Vector3 direction, Vector3 gravity, Vector3 deviation)  {
 	
 	isScreenEmitter = false;
 	dirVector = direction;
@@ -63,6 +89,8 @@ ParticleEmitter::ParticleEmitter(String imageFile, Mesh *particleMesh, int parti
 	isEmitterEnabled = true;
 	allAtOnce = false;
 	
+	this->particleType = particleType;
+	
 	this->numParticles = numParticles;
 
 	this->lifespan = lifespan;
@@ -74,10 +102,10 @@ ParticleEmitter::ParticleEmitter(String imageFile, Mesh *particleMesh, int parti
 
 void ParticleEmitter::createParticles() {
 	
-	if(isScreenEmitter)
+//	if(isScreenEmitter)
 		particleTexture = CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(textureFile);	
-	else
-		particleMaterial = (Material*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_MATERIAL, textureFile);	
+//	else
+//		particleMaterial = (Material*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_MATERIAL, textureFile);	
 	
 	
 	Particle *particle;	
@@ -90,12 +118,12 @@ void ParticleEmitter::createParticles() {
 		particles.push_back(particle);
 		addParticleBody(particle->particleBody);					
 		resetParticle(particle);
-		particle->life = lifespan * ((float)rand()/RAND_MAX);		
+		particle->life = lifespan * ((Number)rand()/RAND_MAX);		
 	}
 	updateEmitter();	
 }
 
-void ParticleEmitter::setEmitterRadius(float rad) {
+void ParticleEmitter::setEmitterRadius(Number rad) {
 	emitterRadius = rad;
 }
 
@@ -107,15 +135,15 @@ void ParticleEmitter::setStartingColor(Color c) {
 	startingColor = c;
 }
 
-void ParticleEmitter::setRotationSpeed(float speed) {
+void ParticleEmitter::setRotationSpeed(Number speed) {
 	rotationSpeed = speed;
 }
 
-void ParticleEmitter::setStartingScaleModifier(float mod) {
+void ParticleEmitter::setStartingScaleModifier(Number mod) {
 	startingScaleMod = mod;
 }
 
-void ParticleEmitter::setEndingScaleModifier(float mod) {
+void ParticleEmitter::setEndingScaleModifier(Number mod) {
 	endingScaleMod = mod;
 }
 
@@ -133,10 +161,17 @@ void ParticleEmitter::setAlphaTest(bool val) {
 
 void ParticleEmitter::setDepthWrite(bool val) {
 	for(int i=0;i < particles.size(); i++) {
-		particles[i]->particleBody->setDepthWrite(true);
+		particles[i]->particleBody->setDepthWrite(val);
 	}	
 }
 
+void ParticleEmitter::setDepthTest(bool val) {
+	for(int i=0;i < particles.size(); i++) {
+		particles[i]->particleBody->depthTest= val;
+	}	
+}
+
+
 void ParticleEmitter::setBillboardMode(bool mode) {
 	for(int i=0;i < particles.size(); i++) {
 		particles[i]->particleBody->billboardMode = mode;
@@ -169,7 +204,7 @@ void ParticleEmitter::setParticleCount(int count) {
 			particle->dirVector = dirVector;
 			particle->deviation = deviation;
 			particle->lifespan = lifespan;
-			particle->life = lifespan * ((float)rand()/RAND_MAX);
+			particle->life = lifespan * ((Number)rand()/RAND_MAX);
 			particles.push_back(particle);
 			addParticleBody(particle->particleBody);
 		}
@@ -184,7 +219,7 @@ void ParticleEmitter::setParticleCount(int count) {
 
 }
 
-void ParticleEmitter::setPerlinModSize(float size) {
+void ParticleEmitter::setPerlinModSize(Number size) {
 	perlinModSize = size;
 
 }
@@ -193,7 +228,7 @@ void ParticleEmitter::enableEmitter(bool val) {
 	isEmitterEnabled = val;
 	if(val) {
 		for(int i=0;i < numParticles; i++) {
-			particles[i]->life = particles[i]->lifespan * ((float)rand()/RAND_MAX);
+			particles[i]->life = particles[i]->lifespan * ((Number)rand()/RAND_MAX);
 		}
 	}
 }
@@ -221,28 +256,28 @@ void ParticleEmitter::resetParticle(Particle *particle) {
 //		startVector = *randPoly->getVertex(rand() % 3);
 //		startVector = emitterMesh->getConcatenatedMatrix() * startVector;
 //	} else {
-		startVector = Vector3(-(emitterRadius/2.0f)+emitterRadius*((float)rand()/RAND_MAX),-(emitterRadius/2.0f)+emitterRadius*((float)rand()/RAND_MAX),-(emitterRadius/2.0f)+emitterRadius*((float)rand()/RAND_MAX));	
+		startVector = Vector3(-(emitterRadius/2.0f)+emitterRadius*((Number)rand()/RAND_MAX),-(emitterRadius/2.0f)+emitterRadius*((Number)rand()/RAND_MAX),-(emitterRadius/2.0f)+emitterRadius*((Number)rand()/RAND_MAX));	
 //	}
 	
-	particle->Reset();	
+	particle->Reset(emitterType != TRIGGERED_EMITTER);	
 	particle->velVector = particle->dirVector;
-	float dev = ((deviation.x/2.0f)*-1.0f) + ((deviation.x)*((float)rand()/RAND_MAX));
+	Number dev = ((deviation.x/2.0f)*-1.0f) + ((deviation.x)*((Number)rand()/RAND_MAX));
 	particle->velVector.x += dev;
-	dev = (deviation.y/2.0f*-1.0f) + ((deviation.y)*((float)rand()/RAND_MAX));
+	dev = (deviation.y/2.0f*-1.0f) + ((deviation.y)*((Number)rand()/RAND_MAX));
 	particle->velVector.y += dev;
-	dev = (deviation.z/2.0f*-1.0f) + ((deviation.z)*((float)rand()/RAND_MAX));
+	dev = (deviation.z/2.0f*-1.0f) + ((deviation.z)*((Number)rand()/RAND_MAX));
 	particle->velVector.z += dev;
 	
-	particle->brightnessDeviation = 1.0f - ( (-brightnessDeviation) + ((brightnessDeviation*2) * ((float)rand()/RAND_MAX)));
+	particle->brightnessDeviation = 1.0f - ( (-brightnessDeviation) + ((brightnessDeviation*2) * ((Number)rand()/RAND_MAX)));
 	
 	particle->velVector = concatMatrix.rotateVector(particle->velVector);	
 	particle->particleBody->setTransformByMatrix(concatMatrix);
 	particle->particleBody->Translate(startVector);
 	particle->particleBody->rebuildTransformMatrix();	
 	
-//	particle->particleBody->setPitch(emitRotationVector.y+(emitRotationDeviance.y*((float)rand()/RAND_MAX)));
-//	particle->particleBody->setRoll(emitRotationVector.x+(emitRotationDeviance.x*((float)rand()/RAND_MAX)));
-//	particle->particleBody->setYaw(emitRotationVector.z+(emitRotationDeviance.z*((float)rand()/RAND_MAX)));	
+//	particle->particleBody->setPitch(emitRotationVector.y+(emitRotationDeviance.y*((Number)rand()/RAND_MAX)));
+//	particle->particleBody->setRoll(emitRotationVector.x+(emitRotationDeviance.x*((Number)rand()/RAND_MAX)));
+//	particle->particleBody->setYaw(emitRotationVector.z+(emitRotationDeviance.z*((Number)rand()/RAND_MAX)));	
 	
 	particle->particleBody->setScale(scaleCurve.getHeightAt(0),
 									 scaleCurve.getHeightAt(0),
@@ -262,17 +297,17 @@ void ParticleEmitter::setAllAtOnce(bool val) {
 		if(allAtOnce)
 			particles[i]->life = 0;
 		else
-			particles[i]->life = particles[i]->lifespan * ((float)rand()/RAND_MAX);
+			particles[i]->life = particles[i]->lifespan * ((Number)rand()/RAND_MAX);
 	}
 }
 
 void ParticleEmitter::updateEmitter() {	
 	
 	Vector3 translationVector;
-	float elapsed = timer->getElapsedf();
+	Number elapsed = timer->getElapsedf();
 	
 	Particle *particle;
-	float normLife;
+	Number normLife;
 	
 	for(int i=0;i < numParticles; i++) {				
 		particle = particles[i];
@@ -317,7 +352,7 @@ void ParticleEmitter::updateEmitter() {
 			if(emitterType == CONTINUOUS_EMITTER) {
 				resetParticle(particle);
 			} else {
-				particle->particleBody->visible = false;
+//				particle->particleBody->visible = false;
 			}
 		}
 	}

Core/Contents/Source/PolyPerlin.cpp

@@ -32,10 +32,10 @@ using namespace Polycode;
 	r0 = t - (int)t;\
 	r1 = r0 - 1.0f;
 
-float Perlin::noise1(float arg)
+Number Perlin::noise1(Number arg)
 {
 	int bx0, bx1;
-	float rx0, rx1, sx, t, u, v, vec[1];
+	Number rx0, rx1, sx, t, u, v, vec[1];
 
 	vec[0] = arg;
 
@@ -56,10 +56,10 @@ float Perlin::noise1(float arg)
 	return lerp(sx, u, v);
 }
 
-float Perlin::noise2(float vec[2])
+Number Perlin::noise2(Number vec[2])
 {
 	int bx0, bx1, by0, by1, b00, b10, b01, b11;
-	float rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
+	Number rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
 	int i, j;
 
 	if (mStart)
@@ -100,10 +100,10 @@ float Perlin::noise2(float vec[2])
 	return lerp(sy, a, b);
 }
 
-float Perlin::noise3(float vec[3])
+Number Perlin::noise3(Number vec[3])
 {
 	int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
-	float rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
+	Number rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
 	int i, j;
 
 	if (mStart)
@@ -154,21 +154,21 @@ float Perlin::noise3(float vec[3])
 	return lerp(sz, c, d);
 }
 
-void Perlin::normalize2(float v[2])
+void Perlin::normalize2(Number v[2])
 {
-	float s;
+	Number s;
 
-	s = (float)sqrt(v[0] * v[0] + v[1] * v[1]);
+	s = (Number)sqrt(v[0] * v[0] + v[1] * v[1]);
   s = 1.0f/s;
 	v[0] = v[0] * s;
 	v[1] = v[1] * s;
 }
 
-void Perlin::normalize3(float v[3])
+void Perlin::normalize3(Number v[3])
 {
-	float s;
+	Number s;
 
-	s = (float)sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+	s = (Number)sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
   s = 1.0f/s;
 
 	v[0] = v[0] * s;
@@ -183,12 +183,12 @@ void Perlin::init(void)
 	for (i = 0 ; i < B ; i++)
   {
 		p[i] = i;
-		g1[i] = (float)((rand() % (B + B)) - B) / B;
+		g1[i] = (Number)((rand() % (B + B)) - B) / B;
 		for (j = 0 ; j < 2 ; j++)
-			g2[i][j] = (float)((rand() % (B + B)) - B) / B;
+			g2[i][j] = (Number)((rand() % (B + B)) - B) / B;
 		normalize2(g2[i]);
 		for (j = 0 ; j < 3 ; j++)
-			g3[i][j] = (float)((rand() % (B + B)) - B) / B;
+			g3[i][j] = (Number)((rand() % (B + B)) - B) / B;
 		normalize3(g3[i]);
 	}
 
@@ -212,12 +212,12 @@ void Perlin::init(void)
 }
 
 
-float Perlin::perlin_noise_2D(float vec[2])
+Number Perlin::perlin_noise_2D(Number vec[2])
 {
   int terms    = mOctaves;
-	float freq   = mFrequency;
-	float result = 0.0f;
-  float amp = mAmplitude;
+	Number freq   = mFrequency;
+	Number result = 0.0f;
+  Number amp = mAmplitude;
 
   vec[0]*=mFrequency;
   vec[1]*=mFrequency;
@@ -236,7 +236,7 @@ float Perlin::perlin_noise_2D(float vec[2])
 
 
 
-Perlin::Perlin(int octaves,float freq,float amp,int seed)
+Perlin::Perlin(int octaves,Number freq,Number amp,int seed)
 {
   mOctaves = octaves;
   mFrequency = freq;

Core/Contents/Source/PolyPolygon.cpp

@@ -15,6 +15,16 @@ Polygon::Polygon()  : useVertexNormals(false), vertexCount(0), useFaceUV(false)
 	normal = new Vector3();
 	hasSecUVs = false;
 	useVertexNormals = true;
+	
+	for(int i=0; i < 3; i++) {
+		Vector2 *newCoord = new Vector2(0,0);
+		texCoords.push_back(newCoord);
+	}
+	
+	for(int i=0; i < 3; i++) {	
+		Vector2 *newCoord2 = new Vector2(0,0);
+		texCoords2.push_back(newCoord2);
+	}
 }
 
 Polygon::~Polygon() {
@@ -92,6 +102,10 @@ Rectangle Polygon::getBounds2D() {
 	
 	return retBox;
 }
+	
+void Polygon::removeVertex(int index) {
+	vertices.erase(vertices.begin() + index);
+}
 
 void Polygon::setNormal(Vector3 normal) {
 	*this->normal = normal;
@@ -116,28 +130,28 @@ void Polygon::calculateNormal() {
 	}
 }
 
-Vertex *Polygon::addVertex(float x, float y, float z) {
+Vertex *Polygon::addVertex(Number x, Number y, Number z) {
 	Vertex *vertex = new Vertex(x,y,z);
 	vertices.push_back(vertex);
 	return vertex;
 }
 
-void Polygon::addTexCoord2(float u, float v) {
-	Vector2 *newCoord = new Vector2(u,v);
-	texCoords2.push_back(newCoord);
+void Polygon::addTexCoord2(Number u, Number v) {
+//	Vector2 *newCoord = new Vector2(u,v);
+//	texCoords2.push_back(newCoord);
 	hasSecUVs =true;
 }
 
-void Polygon::addTexCoord(float u, float v) {
-	Vector2 *newCoord = new Vector2(u,v);
-	texCoords.push_back(newCoord);
+void Polygon::addTexCoord(Number u, Number v) {
+//	Vector2 *newCoord = new Vector2(u,v);
+//	texCoords.push_back(newCoord);
 }
 
 void Polygon::addVertex(Vertex *vertex) {
 	vertices.push_back(vertex);
 }
 
-Vertex *Polygon::addVertex(float x, float y, float z, float u, float v) {
+Vertex *Polygon::addVertex(Number x, Number y, Number z, Number u, Number v) {
 	Vertex *vertex = new Vertex(x,y,z,u,v);
 	vertices.push_back(vertex);
 	return vertex;

Core/Contents/Source/PolyQuaternion.cpp

@@ -19,31 +19,31 @@ Quaternion::~Quaternion() {
 
 }
 
-void Quaternion::createFromAxisAngle(float ax, float ay, float az, float degrees)
+void Quaternion::createFromAxisAngle(Number ax, Number ay, Number az, Number degrees)
 {
-	float angle = float((degrees / 180.0f) * PI);
-	float result = (float)sin( angle / 2.0f );
-	w = (float)cos( angle / 2.0f );
-	x = float(ax * result);
-	y = float(ay * result);
-	z = float(az * result);
+	Number angle = Number((degrees / 180.0f) * PI);
+	Number result = (Number)sin( angle / 2.0f );
+	w = (Number)cos( angle / 2.0f );
+	x = Number(ax * result);
+	y = Number(ay * result);
+	z = Number(az * result);
 }
 
 Matrix4 Quaternion::createMatrix()
 {
 	Matrix4 m;
-        float fTx  = 2.0*x;
-        float fTy  = 2.0*y;
-        float fTz  = 2.0*z;
-        float fTwx = fTx*w;
-        float fTwy = fTy*w;
-        float fTwz = fTz*w;
-        float fTxx = fTx*x;
-        float fTxy = fTy*x;
-        float fTxz = fTz*x;
-        float fTyy = fTy*y;
-        float fTyz = fTz*y;
-        float fTzz = fTz*z;
+        Number fTx  = 2.0*x;
+        Number fTy  = 2.0*y;
+        Number fTz  = 2.0*z;
+        Number fTwx = fTx*w;
+        Number fTwy = fTy*w;
+        Number fTwz = fTz*w;
+        Number fTxx = fTx*x;
+        Number fTxy = fTy*x;
+        Number fTxz = fTz*x;
+        Number fTyy = fTy*y;
+        Number fTyz = fTz*y;
+        Number fTzz = fTz*z;
 
         m[0][0] = 1.0-(fTyy+fTzz);
         m[1][0] = fTxy-fTwz;
@@ -57,7 +57,7 @@ Matrix4 Quaternion::createMatrix()
 	return m;
 }
 
-    float Quaternion::Dot (const Quaternion& rkQ) const
+    Number Quaternion::Dot (const Quaternion& rkQ) const
     {
         return w*rkQ.w+x*rkQ.x+y*rkQ.y+z*rkQ.z;
     }
@@ -73,12 +73,12 @@ Matrix4 Quaternion::createMatrix()
         );
     }
 
-    Quaternion Quaternion::operator* (float fScalar) const
+    Quaternion Quaternion::operator* (Number fScalar) const
     {
         return Quaternion(fScalar*w,fScalar*x,fScalar*y,fScalar*z);
     }
 
-    Quaternion operator* (float fScalar, const Quaternion& rkQ)
+    Quaternion operator* (Number fScalar, const Quaternion& rkQ)
     {
         return Quaternion(fScalar*rkQ.w,fScalar*rkQ.x,fScalar*rkQ.y,
             fScalar*rkQ.z);
@@ -95,15 +95,15 @@ Matrix4 Quaternion::createMatrix()
         // exp(q) = cos(A)+sin(A)*(x*i+y*j+z*k).  If sin(A) is near zero,
         // use exp(q) = cos(A)+A*(x*i+y*j+z*k) since A/sin(A) has limit 1.
 
-        float fAngle ( sqrtf(x*x+y*y+z*z) );
-        float fSin = sinf(fAngle);
+        Number fAngle ( sqrtf(x*x+y*y+z*z) );
+        Number fSin = sinf(fAngle);
 
         Quaternion kResult;
         kResult.w = cosf(fAngle);
 
         if ( fabs(fSin) >= 1e-03 )
         {
-            float fCoeff = fSin/fAngle;
+            Number fCoeff = fSin/fAngle;
             kResult.x = fCoeff*x;
             kResult.y = fCoeff*y;
             kResult.z = fCoeff*z;
@@ -120,10 +120,10 @@ Matrix4 Quaternion::createMatrix()
 	
 	Quaternion Quaternion::Inverse () const
     {
-        float fNorm = w*w+x*x+y*y+z*z;
+        Number fNorm = w*w+x*x+y*y+z*z;
         if ( fNorm > 0.0 )
         {
-            float fInvNorm = 1.0/fNorm;
+            Number fInvNorm = 1.0/fNorm;
             return Quaternion(w*fInvNorm,-x*fInvNorm,-y*fInvNorm,-z*fInvNorm);
         }
         else
@@ -141,11 +141,11 @@ Matrix4 Quaternion::createMatrix()
 
         if ( fabs(w) < 1.0 )
         {
-            float fAngle ( acosf(w) );
-            float fSin = sinf(fAngle);
+            Number fAngle ( acosf(w) );
+            Number fSin = sinf(fAngle);
             if ( fabs(fSin) >= 1e-03 )
             {
-                float fCoeff = fAngle/fSin;
+                Number fCoeff = fAngle/fSin;
                 kResult.x = fCoeff*x;
                 kResult.y = fCoeff*y;
                 kResult.z = fCoeff*z;
@@ -160,22 +160,22 @@ Matrix4 Quaternion::createMatrix()
         return kResult;
     }
 
-    float Quaternion::Norm () const
+    Number Quaternion::Norm () const
     {
         return w*w+x*x+y*y+z*z;
     }
 
-    float Quaternion::normalise(void)
+    Number Quaternion::normalise(void)
     {
-        float len = Norm();
-        float factor = 1.0f / sqrtf(len);
+        Number len = Norm();
+        Number factor = 1.0f / sqrtf(len);
         *this = *this * factor;
         return len;
     }
 
-    Quaternion Quaternion::Slerp(float fT, const Quaternion& rkP, const Quaternion& rkQ, bool shortestPath)
+    Quaternion Quaternion::Slerp(Number fT, const Quaternion& rkP, const Quaternion& rkQ, bool shortestPath)
     {
-        float fCos = rkP.Dot(rkQ);
+		Number fCos = rkP.Dot(rkQ);
         Quaternion rkT;
 
         // Do we need to invert rotation?
@@ -192,11 +192,11 @@ Matrix4 Quaternion::createMatrix()
         if (fabs(fCos) < 1 - 1e-03)
         {
             // Standard case (slerp)
-            float fSin = sqrtf(1 - (fCos*fCos));
-            float fAngle = atan2f(fSin, fCos);
-            float fInvSin = 1.0f / fSin;
-            float fCoeff0 = sinf((1.0f - fT) * fAngle) * fInvSin;
-            float fCoeff1 = sinf(fT * fAngle) * fInvSin;
+            Number fSin = sqrtf(1 - (fCos*fCos));
+            Number fAngle = atan2f(fSin, fCos);
+            Number fInvSin = 1.0f / fSin;
+            Number fCoeff0 = sinf((1.0f - fT) * fAngle) * fInvSin;
+            Number fCoeff1 = sinf(fT * fAngle) * fInvSin;
             return fCoeff0 * rkP + fCoeff1 * rkT;
         }
         else
@@ -214,14 +214,14 @@ Matrix4 Quaternion::createMatrix()
         }
     }
 	
-    Quaternion Quaternion::Squad (float fT,
+    Quaternion Quaternion::Squad (Number fT,
         const Quaternion& rkP, const Quaternion& rkA,
         const Quaternion& rkB, const Quaternion& rkQ, bool shortestPath)
     {
-        float fSlerpT = 2.0*fT*(1.0-fT);
+        Number fSlerpT = 2.0*fT*(1.0-fT);
         Quaternion kSlerpP = Slerp(fT, rkP, rkQ, shortestPath);
-        Quaternion kSlerpQ = Slerp(fT, rkA, rkB);
-        return Slerp(fSlerpT, kSlerpP ,kSlerpQ);
+        Quaternion kSlerpQ = Slerp(fT, rkA, rkB, shortestPath);
+        return Slerp(fSlerpT, kSlerpP ,kSlerpQ, shortestPath);
     }	
 
 Quaternion Quaternion::operator *(Quaternion q)

Core/Contents/Source/PolyQuaternionCurve.cpp

@@ -55,10 +55,10 @@ void QuaternionCurve::generatePointsFromCurves(BezierCurve *wCurve, BezierCurve
 	}
 }
 
-    Quaternion QuaternionCurve::interpolate(float t, bool useShortestPath)
+    Quaternion QuaternionCurve::interpolate(Number t, bool useShortestPath)
     {
         // Work out which segment this is in
-        float fSeg = t * (tPoints.size() - 1);
+        Number fSeg = t * (tPoints.size() - 1);
         unsigned int segIdx = (unsigned int)fSeg;
         // Apportion t 
         t = fSeg - segIdx;
@@ -67,7 +67,7 @@ void QuaternionCurve::generatePointsFromCurves(BezierCurve *wCurve, BezierCurve
 
     }
     //---------------------------------------------------------------------
-    Quaternion QuaternionCurve::interpolate(unsigned int fromIndex, float t,
+    Quaternion QuaternionCurve::interpolate(unsigned int fromIndex, Number t,
 		bool useShortestPath)
     {
         // Bounds check
@@ -98,7 +98,6 @@ void QuaternionCurve::generatePointsFromCurves(BezierCurve *wCurve, BezierCurve
         Quaternion &b = tPoints[fromIndex+1].q1;		
 		
 		if ((fromIndex + 1) == tPoints.size() && tPoints[fromIndex].q2 == tPoints[0].q2) {
-			Logger::log("ASDASDADS\n");
 			q = tPoints[1].q2;
 			b = tPoints[1].q1;					
 		} 

Core/Contents/Source/PolyRectangle.cpp

@@ -11,7 +11,7 @@
 
 using namespace Polycode;
 
-void Rectangle::setRect(float x, float y, float w, float h) {
+void Rectangle::setRect(Number x, Number y, Number w, Number h) {
 	this->x = x;
 	this->y = y;
 	this->w = w;

Core/Contents/Source/PolyRenderer.cpp

@@ -56,20 +56,20 @@ void Renderer::addShadowMap(Texture *texture) {
 	shadowMapTextures.push_back(texture);
 }
 
-void Renderer::setExposureLevel(float level) {
+void Renderer::setExposureLevel(Number level) {
 	exposureLevel = level;
 }
 
 bool Renderer::rayTriangleIntersect(Vector3 ray_origin, Vector3 ray_direction, Vector3 vert0, Vector3 vert1, Vector3 vert2, Vector3 *hitPoint)
 {
-	float t,u,v;
+	Number t,u,v;
 	t = 0; u = 0; v = 0;
 	
 	Vector3 edge1 = vert1 - vert0;
 	Vector3 edge2 = vert2 - vert0;
 	
 	Vector3 tvec, pvec, qvec;
-	float det, inv_det;
+	Number det, inv_det;
 	
 	
 	pvec = ray_direction.crossProduct(edge2);
@@ -108,7 +108,7 @@ void Renderer::addShaderModule(PolycodeShaderModule *module) {
 	shaderModules.push_back(module);
 }
 
-void Renderer::addLight(Vector3 position, Vector3 direction, int type, Color color, float distance, float intensity, Matrix4 *textureMatrix) {
+void Renderer::addLight(Vector3 position, Vector3 direction, int type, Color color, Number distance, Number intensity, Matrix4 *textureMatrix) {
 	numLights++;
 	
 	LightInfo info;
@@ -182,6 +182,7 @@ void Renderer::pushDataArrayForMesh(Mesh *mesh, int arrayType) {
 	if(mesh->arrayDirtyMap[arrayType] == true || mesh->renderDataArrays[arrayType] == NULL) {
 		if(mesh->renderDataArrays[arrayType] != NULL) {
 			free(mesh->renderDataArrays[arrayType]->arrayPtr);
+			delete mesh->renderDataArrays[arrayType];
 		}
 		mesh->renderDataArrays[arrayType] = createRenderDataArrayForMesh(mesh, arrayType);
 		mesh->arrayDirtyMap[arrayType] = false;
@@ -197,7 +198,7 @@ int Renderer::getYRes() {
 	return yRes;
 }
 
-void Renderer::setAmbientColor(float r, float g, float b) {
+void Renderer::setAmbientColor(Number r, Number g, Number b) {
 	ambientColor.setColor(r,g,b,1.0f);
 }
 

Core/Contents/Source/PolyScene.cpp

@@ -65,7 +65,7 @@ void Scene::enableFog(bool enable) {
 	
 }
 
-void Scene::setFogProperties(int fogMode, Color color, float density, float startDepth, float endDepth) {
+void Scene::setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth) {
 	this->fogMode = fogMode;
 	fogColor = color;
 	fogDensity = density;
@@ -76,7 +76,7 @@ void Scene::setFogProperties(int fogMode, Color color, float density, float star
 	
 }
 
-SceneEntity *Scene::getEntityAtCursor(float x, float y) {
+SceneEntity *Scene::getEntityAtCursor(Number x, Number y) {
 	for(int i =0; i< entities.size(); i++) {
 		if(entities[i]->testMouseCollision(x,y)) {
 			return entities[i];

Core/Contents/Source/PolySceneLabel.cpp

@@ -11,13 +11,12 @@
 
 using namespace Polycode;
 
-SceneLabel::SceneLabel(String fontName, String text, int size, float scale, int amode) : SceneEntity() {
+SceneLabel::SceneLabel(String fontName, String text, int size, Number scale, int amode) : SceneEntity() {
 	label = new Label(CoreServices::getInstance()->getFontManager()->getFontByName(fontName), text, size, amode);
 	this->scale = scale;
 	setText(text);
-	texture = NULL;
 	mesh = new Mesh(Mesh::QUAD_MESH);
-	mesh->createPlane(1,1);
+	mesh->createPlane(label->getWidth()*scale,label->getHeight()*scale);
 }
 
 SceneLabel::~SceneLabel() {
@@ -27,7 +26,7 @@ Label *SceneLabel::getLabel() {
 	return label;
 }
 
-bool SceneLabel::testMouseCollision(float x, float y) {
+bool SceneLabel::testMouseCollision(Number x, Number y) {
 	
 	Matrix4 fullMatrix = getConcatenatedMatrix();
 	if(billboardMode) {
@@ -76,7 +75,6 @@ void SceneLabel::setText(String newText) {
 void SceneLabel::Render() {
 	Renderer *renderer = CoreServices::getInstance()->getRenderer();
 	renderer->setTexture(texture);	
-	renderer->pushDataArrayForMesh(mesh, RenderDataArray::COLOR_DATA_ARRAY);
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::VERTEX_DATA_ARRAY);
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::TEXCOORD_DATA_ARRAY);	
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::NORMAL_DATA_ARRAY);		

Core/Contents/Source/PolySceneLight.cpp

@@ -12,7 +12,7 @@
 
 using namespace Polycode;
 
-SceneLight::SceneLight(int type, float intensity, float distance, Scene *parentScene) : SceneEntity() {
+SceneLight::SceneLight(int type, Number intensity, Number distance, Scene *parentScene) : SceneEntity() {
 	this->type = type;
 	this->intensity = intensity;
 	this->distance = distance;
@@ -28,7 +28,7 @@ SceneLight::SceneLight(int type, float intensity, float distance, Scene *parentS
 	shadowsEnabled = false;
 }
 
-void SceneLight::enableShadows(bool val, float resolution) {
+void SceneLight::enableShadows(bool val, Number resolution) {
 	if(val) {
 		if(!zBufferTexture) {
 			CoreServices::getInstance()->getRenderer()->createRenderTextures(NULL, &zBufferTexture, resolution, resolution);
@@ -49,7 +49,7 @@ bool SceneLight::areShadowsEnabled() {
 	return shadowsEnabled;
 }
 
-void SceneLight::setShadowMapFOV(float fov) {
+void SceneLight::setShadowMapFOV(Number fov) {
 	
 }
 
@@ -81,11 +81,11 @@ Texture *SceneLight::getZBufferTexture() {
 	return zBufferTexture;
 }
 
-float SceneLight::getIntensity() {
+Number SceneLight::getIntensity() {
 	return intensity;
 }
 
-float SceneLight::getDistance() {
+Number SceneLight::getDistance() {
 	return distance;
 }
 

Core/Contents/Source/PolySceneLine.cpp

@@ -11,24 +11,43 @@
 
 using namespace Polycode;
 
-SceneLine::SceneLine(Vector3 p1, Vector3 p2) : SceneEntity() {
-	v1.set(p1.x,p1.y,p1.z);
-	v2.set(p2.x,p2.y,p2.z);
+SceneLine::SceneLine(SceneEntity *ent1, SceneEntity *ent2) : SceneEntity() {
+	this->ent1 = ent1;
+	this->ent2 = ent2;	
+
+	mesh = new Mesh(Mesh::LINE_MESH);	
+	
+	Polygon *poly = new Polygon();
+	poly->addVertex(0,0,0);
+	poly->addVertex(0,0,0);	
+	mesh->addPolygon(poly);
+	
+	ignoreParentMatrix = true;
 }
 
 SceneLine::~SceneLine() {
 
 }
-			
-void SceneLine::Render() {
-	/*
-	int rmode = CoreServices::getInstance()->getRenderer()->getRenderMode();
-	CoreServices::getInstance()->getRenderer()->setRenderMode(Renderer::RENDER_MODE_WIREFRAME);
-	CoreServices::getInstance()->getRenderer()->setLineSize(1.0f);
-	CoreServices::getInstance()->getRenderer()->beginRenderOperation(Mesh::TRIFAN_MESH);
-	CoreServices::getInstance()->getRenderer()->draw3DVertex(&v1, NULL);
-	CoreServices::getInstance()->getRenderer()->draw3DVertex(&v2, NULL);
-	CoreServices::getInstance()->getRenderer()->endRenderOperation();
-	CoreServices::getInstance()->getRenderer()->setRenderMode(rmode);
-	 */
+
+
+void SceneLine::Render() {	
+	
+	Vector3 v1;
+	v1 = ent1->getConcatenatedMatrix().getPosition();
+	Vector3 v2;
+	v2 = ent2->getConcatenatedMatrix().getPosition();
+
+	
+	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->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());	
+	
 }

Core/Contents/Source/PolySceneMesh.cpp

@@ -51,8 +51,6 @@ void SceneMesh::setMesh(Mesh *mesh) {
 
 
 SceneMesh::~SceneMesh() {
-	Logger::log("Destroying Scene Mesh...\n");
-	//delete mesh;
 }
 
 Mesh *SceneMesh::getMesh() {
@@ -80,8 +78,8 @@ Texture *SceneMesh::getTexture() {
 }
 
 
-void SceneMesh::loadTexture(String fileName) {
-	texture = CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(fileName);
+void SceneMesh::loadTexture(String fileName,bool clamp) {
+	texture = CoreServices::getInstance()->getMaterialManager()->createTextureFromFile(fileName, clamp);
 }
 
 ShaderBinding *SceneMesh::getLocalShaderOptions() {
@@ -120,6 +118,56 @@ Skeleton *SceneMesh::getSkeleton() {
 void SceneMesh::renderMeshLocally() {
 	Renderer *renderer = CoreServices::getInstance()->getRenderer();
 	
+	if(skeleton) {	
+		for(int i=0; i < mesh->getPolygonCount(); i++) {
+			Polygon *polygon = mesh->getPolygon(i);			
+			unsigned int vCount = polygon->getVertexCount();			
+			for(int j=0; j < vCount; j++) {
+				Vertex *vert = polygon->getVertex(j);
+				Vector3 norm;
+				
+					Vector3 aPos = vert->restPosition;
+					Vector3 tPos;
+				
+					Number mult = 0;
+					for(int b =0; b < vert->getNumBoneAssignments(); b++) {
+						BoneAssignment *bas = vert->getBoneAssignment(b);
+						mult += bas->weight;
+					}
+					mult = 1.0f/mult;
+				
+					for(int b =0; b < vert->getNumBoneAssignments(); b++) {
+						BoneAssignment *bas = vert->getBoneAssignment(b);
+						Bone *bone = bas->bone;
+						if(bone) {
+							
+							Matrix4 restMatrix = bone->getRestMatrix();
+							Matrix4 finalMatrix = bone->getFinalMatrix();
+							
+							Vector3 vec = restMatrix * aPos;
+							tPos += finalMatrix * vec * (bas->weight*mult);
+							
+							Vector3 nvec = vert->restNormal;
+							nvec = restMatrix.rotateVector(nvec);
+							nvec = finalMatrix.rotateVector(nvec);
+							
+							norm += nvec * (bas->weight*mult);
+						}
+					}					
+					
+				
+					vert->x = tPos.x;
+					vert->y = tPos.y;
+					vert->z = tPos.z;				
+				
+					norm.Normalize();
+					vert->setNormal(norm.x, norm.y, norm.z);
+				
+			}
+		}
+		mesh->arrayDirtyMap[RenderDataArray::VERTEX_DATA_ARRAY] = true;		
+		mesh->arrayDirtyMap[RenderDataArray::NORMAL_DATA_ARRAY] = true;		
+	}
 	/*
 	Matrix4 boneMat;
 	for(int i=0; i < mesh->getPolygonCount(); i++) {
@@ -158,7 +206,7 @@ void SceneMesh::renderMeshLocally() {
 			if(polygon->usesFaceUV()) {
 				if(polygon->hasSecUVs)
 					CoreServices::getInstance()->getRenderer()->draw3DVertex2UV(vert, polygon->getTexCoord(j), polygon->getTexCoord2(j));
-				elseBitworld is gonna be included on next month's PC Gamer CD!
+				else
 					CoreServices::getInstance()->getRenderer()->draw3DVertex(vert, polygon->getTexCoord(j));
 			} else {
 				CoreServices::getInstance()->getRenderer()->draw3DVertex(vert, NULL);
@@ -169,9 +217,9 @@ void SceneMesh::renderMeshLocally() {
 	}
 */
 
-//	if(mesh->useVertexColors) {
-//		renderer->pushDataArrayForMesh(mesh, RenderDataArray::COLOR_DATA_ARRAY);
-//	}
+	if(mesh->useVertexColors) {
+		renderer->pushDataArrayForMesh(mesh, RenderDataArray::COLOR_DATA_ARRAY);
+	}
 	 
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::VERTEX_DATA_ARRAY);
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::NORMAL_DATA_ARRAY);		

Core/Contents/Source/PolyScenePrimitive.cpp

@@ -11,11 +11,14 @@
 
 using namespace Polycode;
 
-ScenePrimitive::ScenePrimitive(int type, float v1, float v2, float v3) : SceneMesh(Mesh::QUAD_MESH) {
+ScenePrimitive::ScenePrimitive(int type, Number v1, Number v2, Number v3) : SceneMesh(Mesh::QUAD_MESH) {
 
 	switch(type) {
 		case TYPE_PLANE:
 			mesh->createPlane(v1,v2);
+			bBox.x = v1;
+			bBox.y = v2;
+			bBox.z = 0;
 		break;
 		case TYPE_BOX:
 			mesh->createBox(v1,v2,v3);
@@ -25,6 +28,9 @@ ScenePrimitive::ScenePrimitive(int type, float v1, float v2, float v3) : SceneMe
 		break;
 		case TYPE_SPHERE:
 			mesh->createSphere(v1,v2,v3);
+			bBox.x = v1;
+			bBox.y = v2;
+			bBox.z = v3;						
 		break;
 	}
 }

Core/Contents/Source/PolyScreen.cpp

@@ -30,7 +30,7 @@ Screen::~Screen() {
 	}
 }
 
-void Screen::setNormalizedCoordinates(bool newVal, float yCoordinateSize) {
+void Screen::setNormalizedCoordinates(bool newVal, Number yCoordinateSize) {
 	useNormalizedCoordinates = newVal;
 	this->yCoordinateSize = yCoordinateSize;
 }
@@ -40,7 +40,7 @@ void Screen::handleInputEvent(InputEvent *inputEvent) {
 	for(int i=children.size()-1; i >= 0; i--) {
 		switch(inputEvent->getEventCode()) {
 			case InputEvent::EVENT_MOUSEDOWN:
-				if(children[i]->_onMouseDown(inputEvent->mousePosition.x-offset.x, inputEvent->mousePosition.y-offset.y, inputEvent->timestamp) &&
+				if(children[i]->_onMouseDown(inputEvent->mousePosition.x-offset.x, inputEvent->mousePosition.y-offset.y, inputEvent->mouseButton, inputEvent->timestamp) &&
 				children[i]->blockMouseInput)
 					return;
 			break;
@@ -48,7 +48,7 @@ void Screen::handleInputEvent(InputEvent *inputEvent) {
 				children[i]->_onMouseMove(inputEvent->mousePosition.x-offset.x, inputEvent->mousePosition.y-offset.y, inputEvent->timestamp);
 			break;
 			case InputEvent::EVENT_MOUSEUP:
-				if(children[i]->_onMouseUp(inputEvent->mousePosition.x-offset.x, inputEvent->mousePosition.y-offset.y, inputEvent->timestamp) &&
+				if(children[i]->_onMouseUp(inputEvent->mousePosition.x-offset.x, inputEvent->mousePosition.y-offset.y, inputEvent->mouseButton, inputEvent->timestamp) &&
 				children[i]->blockMouseInput)
 					return;
 			break;
@@ -72,7 +72,7 @@ void Screen::setRenderer(Renderer *renderer) {
 	this->renderer = renderer;
 }
 
-void Screen::setScreenOffset(float x, float y) {
+void Screen::setScreenOffset(Number x, Number y) {
 	offset.x = x;
 	offset.y = y;
 }
@@ -242,7 +242,7 @@ void Screen::Update() {
 
 }
 
-ScreenEntity *Screen::getEntityAt(float x, float y) {
+ScreenEntity *Screen::getEntityAt(Number x, Number y) {
 	for(int i=children.size()-1; i >= 0;i--) {
 		if(children[i]->hitTest(x,y))
 			return children[i];

Core/Contents/Source/PolyScreenCurve.cpp

@@ -20,9 +20,9 @@ ScreenCurve::ScreenCurve(BezierCurve *curve, int numVertices) : ScreenShape(Scre
 	Polygon *poly = new Polygon();
 
 	Color c;
-	float interval = 1.0f/numVertices;
+	Number interval = 1.0f/numVertices;
 	Vector3 vec;
-	float offset = 1.0f;
+	Number offset = 1.0f;
 	Vertex *v;
 	for(int i=0; i < numVertices; i++) {
 		vec = curve->getPointAt(offset);

Core/Contents/Source/PolyScreenEntity.cpp

@@ -21,11 +21,15 @@ ScreenEntity::ScreenEntity() : Entity(), EventDispatcher() {
 	positionMode = POSITION_TOPLEFT;
 	mouseOver = false;
 	isDragged = false;
+
 	dragOffsetX = 0;
 	dragOffsetY = 0;
 	parentEntity = NULL;
 	zindex = 0;
+	
 	depthWrite = false;
+	depthTest = false;
+	
 	focusable = false;
 	hasFocus = false;
 	focusChildren = false;	
@@ -63,7 +67,7 @@ void ScreenEntity::focusNextChild() {
 	}
 }
 
-float ScreenEntity::getRotation() {
+Number ScreenEntity::getRotation() {
 	return this->getRoll();
 }
 
@@ -81,7 +85,7 @@ bool ScreenEntity::isFocusable() {
 	return focusable;
 }
 
-void ScreenEntity::startDrag(float xOffset, float yOffset) {
+void ScreenEntity::startDrag(Number xOffset, Number yOffset) {
 	isDragged = true;
 	dragOffsetX = xOffset;
 	dragOffsetY = yOffset;
@@ -99,27 +103,27 @@ void ScreenEntity::setBlendingMode(int newBlendingMode) {
 	blendingMode = newBlendingMode;
 }
 
-void ScreenEntity::setPosition(float x, float y) {
+void ScreenEntity::setPosition(Number x, Number y) {
 	position.x  = x;
 	position.y  = y;
 	matrixDirty = true;
 }
 
-void ScreenEntity::setScale(float x, float y) {
+void ScreenEntity::setScale(Number x, Number y) {
 	scale.x = x;
 	scale.y = y;
 	matrixDirty = true;	
 }
 
-float ScreenEntity::getWidth() {
+Number ScreenEntity::getWidth() {
 	return width;
 }
 
-float ScreenEntity::getHeight() {
+Number ScreenEntity::getHeight() {
 	return height;
 }
 
-bool ScreenEntity::hitTest(float x, float y) {
+bool ScreenEntity::hitTest(Number x, Number y) {
 	bool retVal = false;
 //			Logger::log("hittest %f,%f in %f %f %f %f\n",x, y, position.x, position.y, hitwidth, hitheight);	
 	switch(positionMode) {
@@ -171,7 +175,7 @@ void ScreenEntity::clearDragLimits() {
 	dragLimits = NULL;
 }
 
-void ScreenEntity::_onMouseMove(float x, float y, int timestamp) {
+void ScreenEntity::_onMouseMove(Number x, Number y, int timestamp) {
 
 	if(isDragged) {
 		setPosition(x-dragOffsetX,y-dragOffsetY);
@@ -213,25 +217,32 @@ void ScreenEntity::_onMouseMove(float x, float y, int timestamp) {
 	}
 }
 
-bool ScreenEntity::_onMouseUp(float x, float y, int timestamp) {
+bool ScreenEntity::_onMouseUp(Number x, Number y, int mouseButton, int timestamp) {
 	bool retVal = false;
 	if(hitTest(x,y) && enabled) {
 		onMouseUp(x,y);
-		dispatchEvent(new InputEvent(Vector2(x,y), timestamp), InputEvent::EVENT_MOUSEUP);
+		
+		InputEvent *inputEvent = new InputEvent(Vector2(x,y), timestamp);		
+		inputEvent->mouseButton = mouseButton;		
+		dispatchEvent(inputEvent, InputEvent::EVENT_MOUSEUP);
 		retVal = true;		
 	} else {
-		dispatchEvent(new InputEvent(Vector2(x,y), timestamp), InputEvent::EVENT_MOUSEUP_OUTSIDE);
+		
+		InputEvent *inputEvent = new InputEvent(Vector2(x,y), timestamp);		
+		inputEvent->mouseButton = mouseButton;
+		
+		dispatchEvent(inputEvent, InputEvent::EVENT_MOUSEUP_OUTSIDE);
 	}
 	
 	if(enabled) {
 		for(int i=0;i<children.size();i++) {
-			((ScreenEntity*)children[i])->_onMouseUp(x-position.x,y-position.y, timestamp);
+			((ScreenEntity*)children[i])->_onMouseUp(x-position.x,y-position.y, mouseButton, timestamp);
 		}
 	}
 	return retVal;
 }
 
-void ScreenEntity::_onMouseWheelUp(float x, float y, int timestamp) {
+void ScreenEntity::_onMouseWheelUp(Number x, Number y, int timestamp) {
 	bool doTest = true;
 	
 	if(hasMask) {
@@ -257,7 +268,7 @@ void ScreenEntity::_onMouseWheelUp(float x, float y, int timestamp) {
 	}	
 }
 
-void ScreenEntity::_onMouseWheelDown(float x, float y, int timestamp) {
+void ScreenEntity::_onMouseWheelDown(Number x, Number y, int timestamp) {
 	bool doTest = true;
 	
 	if(hasMask) {
@@ -284,7 +295,7 @@ void ScreenEntity::_onMouseWheelDown(float x, float y, int timestamp) {
 }
 
 
-bool ScreenEntity::_onMouseDown(float x, float y, int timestamp) {
+bool ScreenEntity::_onMouseDown(Number x, Number y, int mouseButton, int timestamp) {
 	bool retVal = false;
 	
 	bool doTest = true;
@@ -298,16 +309,23 @@ bool ScreenEntity::_onMouseDown(float x, float y, int timestamp) {
 	if(doTest) {
 	if(hitTest(x,y) && enabled) {
 		onMouseDown(x,y);
-		dispatchEvent(new InputEvent(Vector2(x,y), timestamp), InputEvent::EVENT_MOUSEDOWN);
-		if(timestamp - lastClickTicks < 400)
-			dispatchEvent(new InputEvent(Vector2(x,y), timestamp), InputEvent::EVENT_DOUBLECLICK);
+		
+		InputEvent *inputEvent = new InputEvent(Vector2(x,y), timestamp);		
+		inputEvent->mouseButton = mouseButton;
+		dispatchEvent(inputEvent, InputEvent::EVENT_MOUSEDOWN);
+		
+		if(timestamp - lastClickTicks < 400) {
+			InputEvent *inputEvent = new InputEvent(Vector2(x,y), timestamp);
+			inputEvent->mouseButton = mouseButton;			
+			dispatchEvent(inputEvent, InputEvent::EVENT_DOUBLECLICK);
+		}
 		lastClickTicks = timestamp;		
 		retVal = true;
 	}
 	if(enabled) {
 		for(int i=children.size()-1;i>=0;i--) {
 			
-			((ScreenEntity*)children[i])->_onMouseDown(x-position.x,y-position.y, timestamp);
+			((ScreenEntity*)children[i])->_onMouseDown(x-position.x,y-position.y, mouseButton, timestamp);
 			if(((ScreenEntity*)children[i])->blockMouseInput && ((ScreenEntity*)children[i])->enabled) {
 				if(((ScreenEntity*)children[i])->hitTest(x-position.x,y-position.y))
 				   break;
@@ -319,7 +337,7 @@ bool ScreenEntity::_onMouseDown(float x, float y, int timestamp) {
 	return retVal;
 }
 
-void ScreenEntity::setRotation(float rotation) {
+void ScreenEntity::setRotation(Number rotation) {
 	setRoll(rotation);
 }
 

Core/Contents/Source/PolyScreenImage.cpp

@@ -41,22 +41,22 @@ ScreenImage::~ScreenImage() {
 
 }
 
-void ScreenImage::setImageCoordinates(float x, float y, float width, float height) {
+void ScreenImage::setImageCoordinates(Number x, Number y, Number width, Number height) {
 	Vertex *vertex;
-	float pixelSizeX = 1/imageWidth;
-	float pixelSizeY = 1/imageHeight;
+	Number pixelSizeX = 1/imageWidth;
+	Number pixelSizeY = 1/imageHeight;
 	
 	this->width = width;
 	this->height = height;
 	hitwidth = width;
 	hitheight = height;
-	float whalf = floor(width/2.0f);
-	float hhalf = floor(height/2.0f);	
+	Number whalf = floor(width/2.0f);
+	Number hhalf = floor(height/2.0f);	
 		
-	float xFloat = x * pixelSizeX;
-	float yFloat = 1 - (y * pixelSizeY);
-	float wFloat = width * pixelSizeX;
-	float hFloat = height * pixelSizeY;
+	Number xFloat = x * pixelSizeX;
+	Number yFloat = 1 - (y * pixelSizeY);
+	Number wFloat = width * pixelSizeX;
+	Number hFloat = height * pixelSizeY;
 	
 	Polygon *imagePolygon = mesh->getPolygon(0);	
 	vertex = imagePolygon->getVertex(0);
@@ -82,10 +82,10 @@ void ScreenImage::setImageCoordinates(float x, float y, float width, float heigh
 	
 }
 
-float ScreenImage::getImageWidth() {
+Number ScreenImage::getImageWidth() {
 	return imageWidth;
 }
 
-float ScreenImage::getImageHeight() {
+Number ScreenImage::getImageHeight() {
 	return imageHeight;	
 }

Core/Contents/Source/PolyScreenLabel.cpp

@@ -28,7 +28,7 @@ Label *ScreenLabel::getLabel() {
 	return label;
 }
 
-void ScreenLabel::addDropShadow(Color color, float size, float offsetX, float offsetY) {
+void ScreenLabel::addDropShadow(Color color, Number size, Number offsetX, Number offsetY) {
 	Image *labelImage = new Image(label);
 	labelImage->fastBlur(size);
 	dropShadowImage = new ScreenImage(labelImage);	

Core/Contents/Source/PolyScreenLine.cpp

@@ -34,7 +34,7 @@ ScreenLine::~ScreenLine() {
 }
 
 
-void ScreenLine::setLineWidth(float width) {
+void ScreenLine::setLineWidth(Number width) {
 	lineWidth = width;
 }
 

Core/Contents/Source/PolyScreenManager.cpp

@@ -69,8 +69,8 @@ void ScreenManager::Update() {
 			if(!screens[i]->usesNormalizedCoordinates()) {
 				renderer->setOrthoMode(renderer->getXRes(), renderer->getYRes());
 			} else {
-				float yCoordinateSize = screens[i]->getYCoordinateSize();
-				float ratio = ((float)renderer->getXRes())/((float)renderer->getYRes());
+				Number yCoordinateSize = screens[i]->getYCoordinateSize();
+				Number ratio = ((Number)renderer->getXRes())/((Number)renderer->getYRes());
 				renderer->setOrthoMode(ratio*yCoordinateSize, yCoordinateSize);								
 			}
 		

Core/Contents/Source/PolyScreenMesh.cpp

@@ -49,7 +49,9 @@ void ScreenMesh::loadTexture(Image *image) {
 void ScreenMesh::Render() {	
 	Renderer *renderer = CoreServices::getInstance()->getRenderer();
 	renderer->setTexture(texture);
-	renderer->pushDataArrayForMesh(mesh, RenderDataArray::COLOR_DATA_ARRAY);
+	if(mesh->useVertexColors) {
+		renderer->pushDataArrayForMesh(mesh, RenderDataArray::COLOR_DATA_ARRAY);
+	}
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::VERTEX_DATA_ARRAY);
 	renderer->pushDataArrayForMesh(mesh, RenderDataArray::TEXCOORD_DATA_ARRAY);	
 	renderer->drawArrays(mesh->getMeshType());

Core/Contents/Source/PolyScreenShape.cpp

@@ -11,8 +11,8 @@
 
 using namespace Polycode;
 
-ScreenShape::ScreenShape(int shapeType, float option1, float option2, float option3, float option4) : ScreenMesh(Mesh::QUAD_MESH) {
-	float DEG2RAD = 3.14159/180;
+ScreenShape::ScreenShape(int shapeType, Number option1, Number option2, Number option3, Number option4) : ScreenMesh(Mesh::QUAD_MESH) {
+	Number DEG2RAD = 3.14159/180;
 	strokeWidth = 1.0f;
 	this->shapeType = shapeType;
 	width = option1;
@@ -54,7 +54,7 @@ ScreenShape::ScreenShape(int shapeType, float option1, float option2, float opti
 				poly->addVertex(cosf(0)*(width/2),sinf(0)*(height/2), 0, (cosf(0)*0.5) + 0.5,(sinf(0) * 0.5)+ 0.5);
 			
 			for (int i=0; i < 361; i+= step) {
-				float degInRad = i*DEG2RAD;
+				Number degInRad = i*DEG2RAD;
 				poly->addVertex(cos(degInRad)*(width/2),sin(degInRad)*(height/2), 0, (cos(degInRad) * 0.5)+ 0.5 ,(sin(degInRad) * 0.5)+ 0.5);
 			}
 			mesh->addPolygon(poly);
@@ -73,15 +73,15 @@ ScreenShape::ScreenShape(int shapeType, float option1, float option2, float opti
 	strokeEnabled = false;
 }
 
-void ScreenShape::setShapeSize(float newWidth, float newHeight) {
+void ScreenShape::setShapeSize(Number newWidth, Number newHeight) {
 	width = newWidth;
 	height = newHeight;
 	
 	hitwidth = width;
 	hitheight = height;	
 	
-	float whalf = floor(width/2.0f);
-	float hhalf = floor(height/2.0f);
+	Number whalf = floor(width/2.0f);
+	Number hhalf = floor(height/2.0f);
 	Polygon *polygon;
 	Vertex *vertex;
 	
@@ -106,11 +106,11 @@ void ScreenShape::setShapeSize(float newWidth, float newHeight) {
 	matrixDirty = true;
 }
 
-void ScreenShape::addShapePoint(float x, float y) {
+void ScreenShape::addShapePoint(Number x, Number y) {
 	customShapePoly->addVertex(x,y,0,0,0);
 }
 
-void ScreenShape::setGradient(float r1, float g1, float b1, float a1, float r2, float g2, float b2, float a2) {
+void ScreenShape::setGradient(Number r1, Number g1, Number b1, Number a1, Number r2, Number g2, Number b2, Number a2) {
 
 	for(int i=0; i < mesh->getPolygon(0)->getVertexCount(); i++) {
 		mesh->getPolygon(0)->getVertex(i)->useVertexColor = true;
@@ -139,11 +139,11 @@ void ScreenShape::clearGradient() {
 	}
 }
 
-void ScreenShape::setStrokeWidth(float width) {
+void ScreenShape::setStrokeWidth(Number width) {
 	strokeWidth = width;
 }
 
-void ScreenShape::setStrokeColor(float r, float g, float b, float a) {
+void ScreenShape::setStrokeColor(Number r, Number g, Number b, Number a) {
 	strokeColor.setColor(r,g,b,a);
 }
 

Core/Contents/Source/PolyScreenSprite.cpp

@@ -13,13 +13,13 @@
 
 using namespace Polycode;
 
-ScreenSprite::ScreenSprite(String fileName, float spriteWidth, float spriteHeight) : ScreenShape(ScreenShape::SHAPE_RECT, spriteWidth, spriteHeight) {
+ScreenSprite::ScreenSprite(String fileName, Number spriteWidth, Number spriteHeight) : ScreenShape(ScreenShape::SHAPE_RECT, spriteWidth, spriteHeight) {
 	this->spriteWidth = spriteWidth;
 	this->spriteHeight = spriteHeight;	
 	loadTexture(fileName);
 		
-	spriteUVWidth = 1.0f / ((float) texture->getWidth() / spriteWidth);
-	spriteUVHeight = 1.0f / ((float) texture->getHeight() / spriteHeight);
+	spriteUVWidth = 1.0f / ((Number) texture->getWidth() / spriteWidth);
+	spriteUVHeight = 1.0f / ((Number) texture->getHeight() / spriteHeight);
 	
 	currentFrame = 0;
 	currentAnimation = NULL;
@@ -29,7 +29,7 @@ ScreenSprite::~ScreenSprite() {
 	
 }
 
-void ScreenSprite::addAnimation(String name, String frames, float speed) {
+void ScreenSprite::addAnimation(String name, String frames, Number speed) {
 	SpriteAnimation *newAnimation = new SpriteAnimation();
 	
 	vector<String> frameNumbers = frames.split(",");
@@ -71,9 +71,9 @@ void ScreenSprite::Update() {
 	if(!currentAnimation)
 		return;
 	
-	float newTick = CoreServices::getInstance()->getCore()->getTicksFloat();
+	Number newTick = CoreServices::getInstance()->getCore()->getTicksFloat();
 	
-	float elapsed = newTick - lastTick;
+	Number elapsed = newTick - lastTick;
 	
 	if(elapsed > currentAnimation->speed) {
 	currentFrame++;
@@ -84,8 +84,8 @@ void ScreenSprite::Update() {
 			currentFrame = 0;
 	}
 	
-	float xOffset = currentAnimation->framesOffsets[currentFrame].x;
-	float yOffset = 1.0f - currentAnimation->framesOffsets[currentFrame].y - spriteUVHeight;
+	Number xOffset = currentAnimation->framesOffsets[currentFrame].x;
+	Number yOffset = 1.0f - currentAnimation->framesOffsets[currentFrame].y - spriteUVHeight;
 	
 	Polygon *imagePolygon = mesh->getPolygon(0);
 		

Core/Contents/Source/PolySkeleton.cpp

@@ -16,6 +16,10 @@ Skeleton::Skeleton(String fileName) : SceneEntity() {
 	currentAnimation = NULL;
 }
 
+Skeleton::Skeleton() {
+	currentAnimation = NULL;	
+}
+
 Skeleton::~Skeleton() {
 }
 
@@ -35,10 +39,35 @@ Bone *Skeleton::getBone(int index) {
 	return bones[index];
 }
 
-void Skeleton::enableBoneLabels(Font *font, float size, float scale) {
+void Skeleton::enableBoneLabels(String labelFont, Number size, Number scale, Color labelColor) {
 	for(int i=0; i < bones.size(); i++) {
-		bones[i]->enableBoneLabel(font, size, scale);
+		bones[i]->enableBoneLabel(labelFont, size, scale,labelColor);
 	}	
+	
+	SceneLabel *label = new SceneLabel(labelFont, "Skeleton", size, scale, Label::ANTIALIAS_FULL);
+	label->setColor(labelColor);
+	label->billboardMode = true;
+	label->setDepthWrite(false);
+	addEntity(label);
+	
+}
+
+void Skeleton::playAnimationByIndex(int index) {
+	if(index > animations.size()-1)
+		return;
+		
+	SkeletonAnimation *anim = animations[index];
+	if(!anim)
+		return;
+	
+	if(anim == currentAnimation)
+		return;
+	
+	if(currentAnimation)
+		currentAnimation->Stop();
+	
+	currentAnimation = anim;
+	anim->Play();	
 }
 
 void Skeleton::playAnimation(String animName) {
@@ -77,6 +106,10 @@ void Skeleton::loadSkeleton(String fileName) {
 		return;
 	}
 	
+	bonesEntity	= new SceneEntity();
+	bonesEntity->visible = false;
+	addChild(bonesEntity);
+	
 	unsigned int numBones;
 	float t[3],rq[4],s[3];
 	
@@ -92,7 +125,7 @@ void Skeleton::loadSkeleton(String fileName) {
 		memset(buffer, 0, 1024);
 		OSBasics::read(buffer, 1, namelen, inFile);
 		
-		Bone *newBone = new Bone(string(buffer));
+		Bone *newBone = new Bone(string(buffer));		
 		
 		OSBasics::read(&hasParent, sizeof(unsigned int), 1, inFile);
 		if(hasParent == 1) {
@@ -112,27 +145,47 @@ void Skeleton::loadSkeleton(String fileName) {
 		newBone->setRotationQuat(rq[0], rq[1], rq[2], rq[3]);
 		newBone->setScale(s[0], s[1], s[2]);
 		newBone->rebuildTransformMatrix();
-		newBone->setRestMatrix(newBone->getTransformMatrix());
+		
+		newBone->setBaseMatrix(newBone->getTransformMatrix());
+		newBone->setBoneMatrix(newBone->getTransformMatrix());
+
+		OSBasics::read(t, sizeof(float), 3, inFile);
+		OSBasics::read(s, sizeof(float), 3, inFile);
+		OSBasics::read(rq, sizeof(float), 4, inFile);
+		
+		Quaternion q;
+		q.set(rq[0], rq[1], rq[2], rq[3]);
+		Matrix4 m = q.createMatrix();
+		m.setPosition(t[0], t[1], t[2]);
+		
+		newBone->setRestMatrix(m);
+		
 	}
 
 	Bone *parentBone;
 //	SceneEntity *bProxy;
+	
 	for(int i=0; i < bones.size(); i++) {
 		if(bones[i]->parentBoneId != -1) {
 			parentBone = bones[bones[i]->parentBoneId];
 			parentBone->addChildBone(bones[i]);
 			bones[i]->setParentBone(parentBone);
-			parentBone->addEntity(bones[i]);
+			parentBone->addEntity(bones[i]);			
+//			addEntity(bones[i]);										
 			
+			SceneLine *connector = new SceneLine(bones[i], parentBone);
+			connector->depthTest = false;
+			bonesEntity->addEntity(connector);				
+			connector->setColor(((Number)(rand() % RAND_MAX)/(Number)RAND_MAX),((Number)(rand() % RAND_MAX)/(Number)RAND_MAX),((Number)(rand() % RAND_MAX)/(Number)RAND_MAX),1.0f);
 		} else {
 //			bProxy = new SceneEntity();
 //			addEntity(bProxy);			
 //			bProxy->addEntity(bones[i]);
-			addEntity(bones[i]);
+			bonesEntity->addChild(bones[i]);
 		}
-		bones[i]->visible = false;			
+	//	bones[i]->visible = false;			
 	}
-	
+	/*
 	unsigned int numAnimations, activeBones,boneIndex,numPoints,numCurves, curveType;
 	OSBasics::read(&numAnimations, sizeof(unsigned int), 1, inFile);
 	//Logger::log("numAnimations: %d\n", numAnimations);
@@ -140,29 +193,30 @@ void Skeleton::loadSkeleton(String fileName) {
 		OSBasics::read(&namelen, sizeof(unsigned int), 1, inFile);
 		memset(buffer, 0, 1024);
 		OSBasics::read(buffer, 1, namelen, inFile);
-		SkeletonAnimation *newAnimation = new SkeletonAnimation(buffer, 3.0f);
+		float length;
+		OSBasics::read(&length, 1, sizeof(float), inFile);
+		SkeletonAnimation *newAnimation = new SkeletonAnimation(buffer, length);
+		
 		OSBasics::read(&activeBones, sizeof(unsigned int), 1, inFile);
 
 	//	Logger::log("activeBones: %d\n", activeBones);		
 		for(int j=0; j < activeBones; j++) {
 			OSBasics::read(&boneIndex, sizeof(unsigned int), 1, inFile);
-			BoneTrack *newTrack = new BoneTrack(bones[boneIndex]);
+			BoneTrack *newTrack = new BoneTrack(bones[boneIndex], length);
 			
 			BezierCurve *curve;
-			float vec1[2],vec2[2],vec3[2];
+			float vec1[2]; //,vec2[2],vec3[2];
 
 			OSBasics::read(&numCurves, sizeof(unsigned int), 1, inFile);
-			//Logger::log("numCurves: %d\n", numCurves);					
+//			Logger::log("numCurves: %d\n", numCurves);					
 			for(int l=0; l < numCurves; l++) {
 				curve = new BezierCurve();
 				OSBasics::read(&curveType, sizeof(unsigned int), 1, inFile);
 				OSBasics::read(&numPoints, sizeof(unsigned int), 1, inFile);
-			//	Logger::log("numPoints: %d\n", numPoints);									
-				for(int k=0; k < numPoints; k++) {
-					OSBasics::read(vec1, sizeof(float), 2, inFile);
-					OSBasics::read(vec2, sizeof(float), 2, inFile);
-					OSBasics::read(vec3, sizeof(float), 2, inFile);								
-					curve->addControlPoint(vec1[0], vec1[1], 0, vec2[0], vec2[1], 0, vec3[0], vec3[1], 0);
+				for(int k=0; k < numPoints; k++) {					
+					OSBasics::read(vec1, sizeof(float), 2, inFile);					
+					curve->addControlPoint2d(vec1[1], vec1[0]);
+//					curve->addControlPoint(vec1[1]-10, vec1[0], 0, vec1[1], vec1[0], 0, vec1[1]+10, vec1[0], 0);
 				}
 				switch(curveType) {
 					case 0:
@@ -186,7 +240,7 @@ void Skeleton::loadSkeleton(String fileName) {
 					case 6:
 						newTrack->QuatZ = curve;					
 					break;
-					case 7:
+					case 7:;
 						newTrack->LocX = curve;					
 					break;
 					case 8:
@@ -202,17 +256,90 @@ void Skeleton::loadSkeleton(String fileName) {
 		}
 		animations.push_back(newAnimation);
 	}
-	
+	*/
 	OSBasics::close(inFile);
 }
 
-void Skeleton::bonesVisible(bool val) {
-	for(int i=0; i < bones.size(); i++) {
-		bones[i]->visible = val;		
+void Skeleton::addAnimation(String name, String fileName) {
+	OSFILE *inFile = OSBasics::open(fileName.c_str(), "rb");
+	if(!inFile) {
+		return;
 	}
+	
+		unsigned int activeBones,boneIndex,numPoints,numCurves, curveType;	
+		float length;
+		OSBasics::read(&length, 1, sizeof(float), inFile);
+		SkeletonAnimation *newAnimation = new SkeletonAnimation(name, length);
+		
+		OSBasics::read(&activeBones, sizeof(unsigned int), 1, inFile);
+		
+		//	Logger::log("activeBones: %d\n", activeBones);		
+		for(int j=0; j < activeBones; j++) {
+			OSBasics::read(&boneIndex, sizeof(unsigned int), 1, inFile);
+			BoneTrack *newTrack = new BoneTrack(bones[boneIndex], length);
+			
+			BezierCurve *curve;
+			float vec1[2]; //,vec2[2],vec3[2];
+			
+			OSBasics::read(&numCurves, sizeof(unsigned int), 1, inFile);
+			//			Logger::log("numCurves: %d\n", numCurves);					
+			for(int l=0; l < numCurves; l++) {
+				curve = new BezierCurve();
+				OSBasics::read(&curveType, sizeof(unsigned int), 1, inFile);
+				OSBasics::read(&numPoints, sizeof(unsigned int), 1, inFile);
+				for(int k=0; k < numPoints; k++) {					
+					OSBasics::read(vec1, sizeof(float), 2, inFile);					
+					curve->addControlPoint2d(vec1[1], vec1[0]);
+					//					curve->addControlPoint(vec1[1]-10, vec1[0], 0, vec1[1], vec1[0], 0, vec1[1]+10, vec1[0], 0);
+				}
+				switch(curveType) {
+					case 0:
+						newTrack->scaleX = curve;
+						break;
+					case 1:
+						newTrack->scaleY = curve;
+						break;
+					case 2:
+						newTrack->scaleZ = curve;					
+						break;
+					case 3:
+						newTrack->QuatW = curve;					
+						break;
+					case 4:
+						newTrack->QuatX = curve;					
+						break;
+					case 5:
+						newTrack->QuatY = curve;					
+						break;
+					case 6:
+						newTrack->QuatZ = curve;					
+						break;
+					case 7:;
+						newTrack->LocX = curve;					
+						break;
+					case 8:
+						newTrack->LocY = curve;					
+						break;
+					case 9:
+						newTrack->LocZ = curve;					
+						break;
+				}
+			}
+			
+			newAnimation->addBoneTrack(newTrack);
+		}
+		animations.push_back(newAnimation);
+	
+	
+	OSBasics::close(inFile);	
 }
 
-BoneTrack::BoneTrack(Bone *bone) {
+void Skeleton::bonesVisible(bool val) {
+	bonesEntity->visible = val;
+}
+
+BoneTrack::BoneTrack(Bone *bone, Number length) {
+	this->length = length;
 	targetBone = bone;
 	scaleX = NULL;
 	scaleY = NULL;
@@ -246,15 +373,30 @@ void BoneTrack::Play() {
 	// TODO: change it so that you can set the tweens to not manually restart so you can calculate the
 	// time per tween
 	
-	float durTime = (LocX->getControlPoint(LocX->getNumControlPoints()-1)->p2.x)/25.0f;
-
-	BezierPathTween *testTween = new BezierPathTween(&LocXVec, LocX, Tween::EASE_NONE, durTime, true);
+		Number durTime = length; //(LocX->getControlPoint(LocX->getNumControlPoints()-1)->p2.x);//25.0f;
+					
+	BezierPathTween *testTween;		
+	if(LocX) {
+		testTween = new BezierPathTween(&LocXVec, LocX, Tween::EASE_NONE, durTime, true);
+		pathTweens.push_back(testTween);
+	}
+	if(LocY) {		
+		testTween = new BezierPathTween(&LocYVec, LocY, Tween::EASE_NONE, durTime, true);
+		pathTweens.push_back(testTween);
+	}
+		
+	if(LocZ) {
+		testTween = new BezierPathTween(&LocZVec, LocZ, Tween::EASE_NONE, durTime, true);
+		pathTweens.push_back(testTween);
+	}
+	testTween = new BezierPathTween(&ScaleXVec, scaleX, Tween::EASE_NONE, durTime, true);
 	pathTweens.push_back(testTween);
-	testTween = new BezierPathTween(&LocYVec, LocY, Tween::EASE_NONE, durTime, true);
+	testTween = new BezierPathTween(&ScaleYVec, scaleY, Tween::EASE_NONE, durTime, true);
 	pathTweens.push_back(testTween);
-	testTween = new BezierPathTween(&LocZVec, LocZ, Tween::EASE_NONE, durTime, true);
+	testTween = new BezierPathTween(&ScaleZVec, scaleZ, Tween::EASE_NONE, durTime, true);
 	pathTweens.push_back(testTween);
-
+		
+		
 	if(QuatW)
 		quatTween = new QuaternionTween(&boneQuat, QuatW, QuatX, QuatY, QuatZ, Tween::EASE_NONE, durTime, true);
 
@@ -291,32 +433,42 @@ void BoneTrack::Play() {
 
 void BoneTrack::Update() {
 
-	//TODO: IMPLEMENT setTransform
-	//newMatrix.setTransform(Vector3(LocXVec.y, LocYVec.y, LocZVec.y), Vector3(1.0f, 1.0f, 1.0f), Quaternion (QuatWVec.y, QuatXVec.y, QuatYVec.y, QuatZVec.y));
-
-//	Quaternion quat(QuatWVec.y, QuatXVec.y, QuatYVec.y, QuatZVec.y);
-//	Quaternion quat; quat.createFromAxisAngle(1,0,0,30);
-	
 	Matrix4 newMatrix;
 	newMatrix = boneQuat.createMatrix();
+
 	
 	Matrix4 scaleMatrix;
-	scaleMatrix.m[0][0] *= 1;
-	scaleMatrix.m[1][1] *= 1;
-	scaleMatrix.m[2][2] *= 1;
+	scaleMatrix.m[0][0] *= 1; //ScaleXVec.y;
+	scaleMatrix.m[1][1] *= 1; //ScaleYVec.y;
+	scaleMatrix.m[2][2] *= 1; //ScaleZVec.y;
+	
 
 	Matrix4 posMatrix;
-	posMatrix.m[3][0] = LocXVec.y;
-	posMatrix.m[3][1] = LocYVec.y;
-	posMatrix.m[3][2] = LocZVec.y;
+
+	if(LocX)
+		posMatrix.m[3][0] = LocXVec.y;		
+	else
+		posMatrix.m[3][0] = targetBone->getBaseMatrix()[3][0];
+
+	if(LocY)
+		posMatrix.m[3][1] = LocYVec.y;		
+	else
+		posMatrix.m[3][1] = targetBone->getBaseMatrix()[3][1];
 	
-	newMatrix = scaleMatrix*newMatrix*posMatrix;
+	if(LocZ)
+		posMatrix.m[3][2] = LocZVec.y;		
+	else
+		posMatrix.m[3][2] = targetBone->getBaseMatrix()[3][2];
+	
+	
+	newMatrix = scaleMatrix*newMatrix*posMatrix;	
 	
 	targetBone->setBoneMatrix(newMatrix);
-	targetBone->setMatrix(newMatrix * targetBone->getRestMatrix());
+	targetBone->setTransformByMatrixPure(newMatrix);		
+
 }
 
-void BoneTrack::setSpeed(float speed) {
+void BoneTrack::setSpeed(Number speed) {
 	for(int i=0; i < pathTweens.size(); i++) {
 		pathTweens[i]->setSpeed(speed);
 	}	
@@ -324,12 +476,12 @@ void BoneTrack::setSpeed(float speed) {
 }
 
 
-SkeletonAnimation::SkeletonAnimation(String name, float duration) {
+SkeletonAnimation::SkeletonAnimation(String name, Number duration) {
 	this->name = name;
 	this->duration = duration;
 }
 
-void SkeletonAnimation::setSpeed(float speed) {
+void SkeletonAnimation::setSpeed(Number speed) {
 	for(int i=0; i < boneTracks.size(); i++) {
 		boneTracks[i]->setSpeed(speed);
 	}	

Core/Contents/Source/PolyString.cpp

@@ -117,7 +117,7 @@ String String::toLowerCase() {
 	return String(str);
 }
 
-String String::floatToString(float value) {
+String String::NumberToString(Number value) {
 	char temp[128];
 	sprintf(temp, "%f", value);
 	return String(temp);

Core/Contents/Source/PolySubstanceView.m

@@ -12,6 +12,8 @@
 @implementation SubstanceView
 
 @synthesize viewReady;
+@synthesize mouseX;
+@synthesize mouseY;
 
 - (id)initWithFrame:(NSRect)frameRect pixelFormat:(NSOpenGLPixelFormat *)format 
 {
@@ -380,6 +382,11 @@
 	newEvent.mouseButton = CoreInput::MOUSE_BUTTON1;
 	newEvent.mouseX = mouseLoc.x;
 	newEvent.mouseY = core->getYRes() - mouseLoc.y;
+	
+	mouseX = mouseLoc.x;
+	mouseY = mouseLoc.y;
+	
+	
 	core->cocoaEvents.push_back(newEvent);	
 	core->unlockMutex(core->eventMutex);	
 }
@@ -397,6 +404,11 @@
 	newEvent.mouseButton = CoreInput::MOUSE_BUTTON1;	
 	newEvent.mouseX = mouseLoc.x;
 	newEvent.mouseY = core->getYRes() - mouseLoc.y;
+	
+	mouseX = mouseLoc.x;
+	mouseY = mouseLoc.y;
+	
+	
 	core->cocoaEvents.push_back(newEvent);	
 	core->unlockMutex(core->eventMutex);	
 }
@@ -507,6 +519,10 @@
 	newEvent.eventCode = InputEvent::EVENT_MOUSEMOVE;
 	newEvent.mouseX = mouseLoc.x;
 	newEvent.mouseY = core->getYRes() - mouseLoc.y;
+	
+	mouseX = mouseLoc.x;
+	mouseY = mouseLoc.y;
+	
 	core->cocoaEvents.push_back(newEvent);	
 	core->unlockMutex(core->eventMutex);
 }