Initial codebase gutting, basic batched renderer outline

Core/Contents/CMakeLists.txt

@@ -19,15 +19,10 @@ SET(polycore_SRCS
     Source/PolyEventHandler.cpp
     Source/PolyFixedShader.cpp
     Source/PolyFont.cpp
-	Source/PolyFontGlyphSheet.cpp
+    Source/PolyFontGlyphSheet.cpp
     Source/PolyFontManager.cpp
-    Source/PolyGLCubemap.cpp
-    Source/PolyGLRenderer.cpp
-    Source/PolyGLSLProgram.cpp
-    Source/PolyGLSLShader.cpp
-    Source/PolyGLSLShaderModule.cpp
-    Source/PolyGLTexture.cpp
-    Source/PolyGLVertexBuffer.cpp
+    Source/PolyGPUDrawBuffer.cpp
+    Source/PolyOpenGLGraphicsInterface.cpp
     Source/PolyImage.cpp
     Source/PolyInputEvent.cpp
     Source/PolyLabel.cpp
@@ -36,7 +31,6 @@ SET(polycore_SRCS
     Source/PolyMaterialManager.cpp
     Source/PolyMatrix4.cpp
     Source/PolyMesh.cpp
-    Source/PolyModule.cpp
     Source/PolyObject.cpp
     Source/PolyParticleEmitter.cpp
     Source/PolyPerlin.cpp
@@ -109,15 +103,9 @@ SET(polycore_HDRS
     Include/PolyFont.h
 	Include/PolyFontGlyphSheet.h
     Include/PolyFontManager.h
-    Include/PolyGLCubemap.h
-    Include/PolyGLHeaders.h
     Include/PolyGlobals.h
-    Include/PolyGLRenderer.h
-    Include/PolyGLSLProgram.h
-    Include/PolyGLSLShader.h
-    Include/PolyGLSLShaderModule.h
-    Include/PolyGLTexture.h
-    Include/PolyGLVertexBuffer.h
+    Include/PolyGPUDrawBuffer.h
+    Include/PolyOpenGLGraphicsInterface.h
     Include/PolyImage.h
     Include/PolyInputEvent.h
     Include/PolyInputKeys.h
@@ -127,7 +115,6 @@ SET(polycore_HDRS
     Include/PolyMaterialManager.h
     Include/PolyMatrix4.h
     Include/PolyMesh.h
-    Include/PolyModule.h
     Include/PolyObject.h
     Include/PolyParticleEmitter.h
     Include/PolyPerlin.h

Core/Contents/Include/PolyCamera.h

@@ -176,10 +176,8 @@ namespace Polycode {
              */
             Scene *getParentScene() const;
 			
-            /**
-             * Sets the renderer viewport and projection/modelview matrices based on the camera's setting and transform.
-             */
-			void doCameraTransform();
+
+            Matrix4 createProjectionMatrix();
 
             /**
              * Check if camera has a post filter material applied
@@ -275,7 +273,9 @@ namespace Polycode {
              * Return's the camera's pixel viewport based on the last render pass.
              */
 			Polycode::Rectangle getViewport();
-			
+
+			void setViewport(const Polycode::Rectangle &viewport);
+        
 			/**
 			* Toggles the frustum culling of the camera. (Defaults to true).
 			*/
@@ -314,6 +314,8 @@ namespace Polycode {
 
 		protected:
 
+            void setOrthoMatrix(Matrix4 &matrix, Number xSize, Number ySize, Number _near, Number _far, bool centered);
+        
             bool useGlobalFramebuffer;
 			int projectionMode;
         

Core/Contents/Include/PolyCocoaCore.h

@@ -30,11 +30,10 @@
 #include <vector>
 #include <OpenGL/gl.h>
 #include <OpenGL/OpenGL.h>
-#include "PolyGLRenderer.h"
+#include "PolyOpenGLGraphicsInterface.h"
 #include <mach/mach_time.h>
 #include <unistd.h>
 #include "PolyInputEvent.h"
-#include "PolyGLSLShaderModule.h"
 #include <IOKit/hid/IOHIDLib.h>
 #import <Cocoa/Cocoa.h>
 
@@ -103,30 +102,20 @@ namespace Polycode {
 			CoreInput *input;		
 	};
 	
-	class VideoModeChangeInfo {
-		public:
-		int xRes;
-		int yRes;
-		bool fullScreen;
-		bool vSync;
-		int aaLevel;
-		int anisotropyLevel;
-		bool needResolutionChange;
-	};
-	
 	class _PolyExport CocoaCore : public Core {		
 	public:
 		
 		CocoaCore(PolycodeView *view, int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, int frameRate, int monitorIndex=-1, bool retinaSupport=false);
 		virtual ~CocoaCore();
 		
+        bool createRenderContext();
+        
 		void enableMouse(bool newval);
 		unsigned int getTicks();		
 		bool systemUpdate();
 		
 		void Render();
 								
-		void setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, bool retinaSupport = true);
 		void resizeTo(int xRes, int yRes);
 		void createThread(Threaded *target);		
 		
@@ -177,17 +166,15 @@ namespace Polycode {
         Number getBackingXRes();
         Number getBackingYRes();
         
-								
+        void handleVideoModeChange(VideoModeChangeInfo *modeInfo);
+        void flushRenderContext();
+        
 	protected:	
-		
-		void _setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel);
 	
 		PolycodeView *glView;
 		uint64_t initTime;
         bool retinaSupport;
-		
-		VideoModeChangeInfo modeChangeInfo;
-		
+				
 		IOHIDManagerRef hidManager;
 	};
 }

Core/Contents/Include/PolyCore.h

@@ -72,7 +72,18 @@ namespace Polycode {
 			int weekDay;
 			int year;
 			int yearDay;
-	};	
+	};
+    
+    class VideoModeChangeInfo {
+    public:
+        int xRes;
+        int yRes;
+        bool fullScreen;
+        bool vSync;
+        int aaLevel;
+        int anisotropyLevel;
+        bool retinaSupport;
+    };
 
 	/**
 	* The main core of the framework. The core deals with system-level functions, such as window initialization and OS interaction. Each platform has its own implementation of this base class. NOTE: SOME OF THE FUNCTIONALITY IN THE CORE IS NOT FULLY IMPLEMENTED!!
@@ -282,7 +293,9 @@ namespace Polycode {
 		
 		virtual String saveFilePicker(std::vector<CoreFileExtension> extensions) = 0;
 
-		
+        virtual void handleVideoModeChange(VideoModeChangeInfo *modeInfo) = 0;
+        virtual void flushRenderContext() = 0;
+        
 		/**
 		* Sets a new video mode.
 		* @param xRes New horizontal resolution of the renderer.
@@ -290,7 +303,7 @@ namespace Polycode {
 		* @param fullScreen True to launch in fullscreen, false to launch in window.
 		* @param aaLevel Level of anti-aliasing. Possible values are 2,4 and 6.
 		*/																									
-		virtual void setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, bool retinaSupport=true) = 0;
+		void setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, bool retinaSupport=true);
 		
 		/**
 		* Resizes the renderer.
@@ -397,7 +410,7 @@ namespace Polycode {
 	protected:	
 	
 		virtual bool checkSpecialKeyEvents(PolyKEY key) { return false; }
-	
+        
 		void loseFocus();
 		void gainFocus();
 		
@@ -431,7 +444,7 @@ namespace Polycode {
 		
 		bool mouseEnabled;
 		bool mouseCaptured;
-		
+        int anisotropyLevel;
 		unsigned int lastSleepFrameTicks;
 		
 		std::vector<Threaded*> threads;
@@ -439,7 +452,8 @@ namespace Polycode {
 		
 		int xRes;
 		int yRes;
-				
+        bool vSync;
+        
 		int monitorIndex;
 		
 		int frames;

Core/Contents/Include/PolyCoreServices.h

@@ -67,7 +67,7 @@ namespace Polycode {
 			
 			void Update(int elapsed);
             void fixedUpdate();
-			void Render();
+			void Render(const Polycode::Rectangle &viewport);
 			
 			void setCore(Core *core);
 		
@@ -91,14 +91,7 @@ namespace Polycode {
             CoreInput *getInput();
 			
 			void handleEvent(Event *event);
-		
-			/**
-			* Installs a plugin module at runtime.
-			* @param module Plugin module to install. See PolygonModule for more details on modules.
-			@see PolycodeModule
-			*/
-			void installModule(PolycodeModule *module);
-			
+
 			/**
 			* Returns the material manager. The material manager is responsible for loading and managing textures, shaders and materials.
 			* @return Material manager.
@@ -175,9 +168,6 @@ namespace Polycode {
 			static CoreServices* overrideInstance;
 			static std::map <long, CoreServices*> instanceMap;
 			static CoreMutex *renderMutex;
-		
-			std::vector<PolycodeModule*> modules;
-			std::vector<PolycodeModule*> updateModules;
 					
 			Core *core;
 			Config *config;

Core/Contents/Include/PolyEntity.h

@@ -30,6 +30,7 @@
 #include "PolyRectangle.h"
 #include "PolyRay.h"
 #include "PolyEventDispatcher.h"
+#include "PolyGPUDrawBuffer.h"
 #include <vector>
 
 namespace Polycode {
@@ -88,16 +89,16 @@ namespace Polycode {
 			/**
 			* Main render method. Override this to do your own drawing.
 			*/
-			virtual void Render(){};
+			virtual void Render(GPUDrawBuffer *buffer){};
 			/**
 			* Main update method. Override this to do your updates before the render cycle.
 			*/			
 			virtual void Update(){};			
 			virtual void fixedUpdate(){};
         
-			void transformAndRender();		
+            void transformAndRender(GPUDrawBuffer *drawBuffer);
 
-			void renderChildren();					
+			void renderChildren(GPUDrawBuffer *buffer);
 		
 			
 			/**
@@ -666,7 +667,9 @@ namespace Polycode {
 			/**
 			* If this flag is set to true, this entity will render only into the depth buffer. This, effectively, means that it will be invisible, but still obscuring other entities.
 			*/
-			bool depthOnly;		
+
+            void setDepthOnly(bool val);
+            bool getDepthOnly();
 			
 			/**
 			* If this flag is set to true, this entity's transformations will not take into account its parent, making its transforms always relative to 0.
@@ -897,9 +900,11 @@ namespace Polycode {
 
             std::vector <EntityProp> entityProps;
         
+            GPUDrawCall drawCall;
+        
 		protected:
+
         
-		
             AABB aabb;
             Vector3 bBox;
         

Core/Contents/Include/PolyGLCubemap.h

@@ -1,62 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "PolyGlobals.h"
-#include "PolyCubemap.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-#if defined(__APPLE__) && defined(__MACH__)
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#include <OpenGL/glu.h>	
-#else
-#include <GL/gl.h>
-#include <GL/glext.h>
-#endif
-
-namespace Polycode {
-	
-	class Texture;
-
-	class _PolyExport OpenGLCubemap : public Cubemap {
-	public:
-		
-		OpenGLCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5);
-		virtual ~OpenGLCubemap();
-		
-		void recreateFromTextures();
-		
-		GLuint getTextureID();		
-			
-	protected:
-	
-		bool glCubemapLoaded;
-		int filteringMode;
-		GLuint textureID;
-	};
-	
-}

Core/Contents/Include/PolyGLHeaders.h

@@ -1,117 +0,0 @@
-#pragma once
-
-#if defined(_WINDOWS) && !defined(_MINGW)
-#include <windows.h>
-#endif
-
-#ifdef _MINGW 
-#include "GLee.h"
-typedef GLEEPFNGLACTIVETEXTUREPROC PFNGLACTIVETEXTUREPROC;
-typedef GLEEPFNGLMULTITEXCOORD2FPROC PFNGLMULTITEXCOORD2FPROC;
-typedef GLEEPFNGLMULTITEXCOORD3FPROC PFNGLMULTITEXCOORD3FPROC;
-typedef GLEEPFNGLBINDBUFFERARBPROC PFNGLBINDBUFFERARBPROC;
-typedef GLEEPFNGLDELETEBUFFERSARBPROC PFNGLDELETEBUFFERSARBPROC;
-typedef GLEEPFNGLGENBUFFERSARBPROC PFNGLGENBUFFERSARBPROC;
-typedef GLEEPFNGLISBUFFERARBPROC PFNGLISBUFFERARBPROC;
-typedef GLEEPFNGLBUFFERDATAARBPROC PFNGLBUFFERDATAARBPROC;
-typedef GLEEPFNGLBUFFERSUBDATAARBPROC PFNGLBUFFERSUBDATAARBPROC;
-typedef GLEEPFNGLGETBUFFERSUBDATAARBPROC PFNGLGETBUFFERSUBDATAARBPROC;
-typedef GLEEPFNGLMAPBUFFERARBPROC PFNGLMAPBUFFERARBPROC;
-typedef GLEEPFNGLUNMAPBUFFERARBPROC PFNGLUNMAPBUFFERARBPROC;
-typedef GLEEPFNGLGETBUFFERPARAMETERIVARBPROC PFNGLGETBUFFERPARAMETERIVARBPROC;
-typedef GLEEPFNGLGETBUFFERPOINTERVARBPROC PFNGLGETBUFFERPOINTERVARBPROC;
-typedef GLEEPFNGLISRENDERBUFFEREXTPROC PFNGLISRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLBINDRENDERBUFFEREXTPROC PFNGLBINDRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLDELETERENDERBUFFERSEXTPROC PFNGLDELETERENDERBUFFERSEXTPROC;
-typedef GLEEPFNGLGENRENDERBUFFERSEXTPROC PFNGLGENRENDERBUFFERSEXTPROC;
-typedef GLEEPFNGLRENDERBUFFERSTORAGEEXTPROC PFNGLRENDERBUFFERSTORAGEEXTPROC;
-typedef GLEEPFNGLGETRENDERBUFFERPARAMETERIVEXTPROC PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC;
-typedef GLEEPFNGLISFRAMEBUFFEREXTPROC PFNGLISFRAMEBUFFEREXTPROC;
-typedef GLEEPFNGLBINDFRAMEBUFFEREXTPROC PFNGLBINDFRAMEBUFFEREXTPROC;
-typedef GLEEPFNGLDELETEFRAMEBUFFERSEXTPROC PFNGLDELETEFRAMEBUFFERSEXTPROC;
-typedef GLEEPFNGLGENFRAMEBUFFERSEXTPROC PFNGLGENFRAMEBUFFERSEXTPROC;
-typedef GLEEPFNGLCHECKFRAMEBUFFERSTATUSEXTPROC PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE1DEXTPROC PFNGLFRAMEBUFFERTEXTURE1DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE2DEXTPROC PFNGLFRAMEBUFFERTEXTURE2DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE3DEXTPROC PFNGLFRAMEBUFFERTEXTURE3DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERRENDERBUFFEREXTPROC PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC;
-typedef GLEEPFNGLGENERATEMIPMAPEXTPROC PFNGLGENERATEMIPMAPEXTPROC;
-typedef GLEEPFNGLACTIVETEXTUREPROC PFNGLACTIVETEXTUREPROC;
-typedef GLEEPFNGLMULTITEXCOORD2FPROC PFNGLMULTITEXCOORD2FPROC;
-typedef GLEEPFNGLMULTITEXCOORD3FPROC PFNGLMULTITEXCOORD3FPROC;
-typedef GLEEPFNGLBINDBUFFERARBPROC PFNGLBINDBUFFERARBPROC;
-typedef GLEEPFNGLDELETEBUFFERSARBPROC PFNGLDELETEBUFFERSARBPROC;
-typedef GLEEPFNGLGENBUFFERSARBPROC PFNGLGENBUFFERSARBPROC;
-typedef GLEEPFNGLISBUFFERARBPROC PFNGLISBUFFERARBPROC;
-typedef GLEEPFNGLBUFFERDATAARBPROC PFNGLBUFFERDATAARBPROC;
-typedef GLEEPFNGLBUFFERSUBDATAARBPROC PFNGLBUFFERSUBDATAARBPROC;
-typedef GLEEPFNGLGETBUFFERSUBDATAARBPROC PFNGLGETBUFFERSUBDATAARBPROC;
-typedef GLEEPFNGLMAPBUFFERARBPROC PFNGLMAPBUFFERARBPROC;
-typedef GLEEPFNGLUNMAPBUFFERARBPROC PFNGLUNMAPBUFFERARBPROC;
-typedef GLEEPFNGLGETBUFFERPARAMETERIVARBPROC PFNGLGETBUFFERPARAMETERIVARBPROC;
-typedef GLEEPFNGLGETBUFFERPOINTERVARBPROC PFNGLGETBUFFERPOINTERVARBPROC;
-typedef GLEEPFNGLISRENDERBUFFEREXTPROC PFNGLISRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLBINDRENDERBUFFEREXTPROC PFNGLBINDRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLDELETERENDERBUFFERSEXTPROC PFNGLDELETERENDERBUFFERSEXTPROC;
-typedef GLEEPFNGLGENRENDERBUFFERSEXTPROC PFNGLGENRENDERBUFFERSEXTPROC;
-typedef GLEEPFNGLRENDERBUFFERSTORAGEEXTPROC PFNGLRENDERBUFFERSTORAGEEXTPROC;
-typedef GLEEPFNGLGETRENDERBUFFERPARAMETERIVEXTPROC PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC;
-typedef GLEEPFNGLISFRAMEBUFFEREXTPROC PFNGLISFRAMEBUFFEREXTPROC;
-typedef GLEEPFNGLBINDFRAMEBUFFEREXTPROC PFNGLBINDFRAMEBUFFEREXTPROC;
-typedef GLEEPFNGLDELETEFRAMEBUFFERSEXTPROC PFNGLDELETEFRAMEBUFFERSEXTPROC;
-typedef GLEEPFNGLGENFRAMEBUFFERSEXTPROC PFNGLGENFRAMEBUFFERSEXTPROC;
-typedef GLEEPFNGLCHECKFRAMEBUFFERSTATUSEXTPROC PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE1DEXTPROC PFNGLFRAMEBUFFERTEXTURE1DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE2DEXTPROC PFNGLFRAMEBUFFERTEXTURE2DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERTEXTURE3DEXTPROC PFNGLFRAMEBUFFERTEXTURE3DEXTPROC;
-typedef GLEEPFNGLFRAMEBUFFERRENDERBUFFEREXTPROC PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC;
-typedef GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC;
-typedef GLEEPFNGLGENERATEMIPMAPEXTPROC PFNGLGENERATEMIPMAPEXTPROC;
-typedef GLEEPFNGLUSEPROGRAMPROC PFNGLUSEPROGRAMPROC;
-typedef GLEEPFNGLUNIFORM1IPROC PFNGLUNIFORM1IPROC;
-typedef GLEEPFNGLGETUNIFORMLOCATIONARBPROC PFNGLGETUNIFORMLOCATIONARBPROC;
-typedef GLEEPFNGLCREATESHADERPROC PFNGLCREATESHADERPROC;
-typedef GLEEPFNGLSHADERSOURCEPROC PFNGLSHADERSOURCEPROC;
-typedef GLEEPFNGLCOMPILESHADERPROC PFNGLCOMPILESHADERPROC;
-typedef GLEEPFNGLCREATEPROGRAMPROC PFNGLCREATEPROGRAMPROC;
-typedef GLEEPFNGLATTACHSHADERPROC PFNGLATTACHSHADERPROC;
-typedef GLEEPFNGLLINKPROGRAMPROC PFNGLLINKPROGRAMPROC;
-typedef GLEEPFNGLDETACHSHADERPROC PFNGLDETACHSHADERPROC;
-typedef GLEEPFNGLDELETESHADERPROC PFNGLDELETESHADERPROC;
-typedef GLEEPFNGLDELETEPROGRAMPROC PFNGLDELETEPROGRAMPROC;
-typedef GLEEPFNGLUNIFORM1FPROC PFNGLUNIFORM1FPROC;
-typedef GLEEPFNGLUNIFORM3FPROC PFNGLUNIFORM3FPROC;
-typedef GLEEPFNGLUNIFORMMATRIX4FVPROC PFNGLUNIFORMMATRIX4FVPROC;
-typedef GLEEPFNGLGETSHADERIVPROC PFNGLGETSHADERIVPROC;
-typedef GLEEPFNGLGETSHADERINFOLOGPROC PFNGLGETSHADERINFOLOGPROC;
-typedef GLEEPFNGLUNIFORMMATRIX4FVPROC PFNGLUNIFORMMATRIX4FVPROC;
-typedef GLEEPFNGLGETSHADERIVPROC PFNGLGETSHADERIVPROC;
-typedef GLEEPFNGLGETSHADERINFOLOGPROC PFNGLGETSHADERINFOLOGPROC;
-typedef GLEEPFNWGLCHOOSEPIXELFORMATARBPROC PFNWGLCHOOSEPIXELFORMATARBPROC;
-typedef GLEEPFNGLVERTEXATTRIBPOINTERPROC PFNGLVERTEXATTRIBPOINTERPROC;
-typedef GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC PFNGLENABLEVERTEXATTRIBARRAYARBPROC;
-typedef GLEEPFNGLBINDATTRIBLOCATIONPROC PFNGLBINDATTRIBLOCATIONPROC;
-typedef GLEEPFNGLVERTEXATTRIBPOINTERPROC PFNGLVERTEXATTRIBPOINTERPROC;
-typedef GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC PFNGLENABLEVERTEXATTRIBARRAYARBPROC;
-typedef GLEEPFNGLBINDATTRIBLOCATIONPROC PFNGLBINDATTRIBLOCATIONPROC;
-typedef GLEEPFNGLUNIFORM2FPROC PFNGLUNIFORM2FPROC;
-typedef GLEEPFNWGLSWAPINTERVALEXTPROC PFNWGLSWAPINTERVALEXTPROC;
-typedef GLEEPFNWGLGETSWAPINTERVALEXTPROC PFNWGLGETSWAPINTERVALEXTPROC;
-typedef GLEEPFNGLGETPROGRAMIVPROC PFNGLGETPROGRAMIVPROC;
-typedef GLEEPFNGLGETACTIVEUNIFORMPROC PFNGLGETACTIVEUNIFORMPROC;
-#endif
-
-#if defined(__APPLE__) && defined(__MACH__)
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-#include <GL/glu.h>
-#include <GL/glext.h>
-
-#if defined(_WINDOWS) && !defined(_MINGW)
-#include <GL/wglext.h>
-#endif
-#endif

Core/Contents/Include/PolyGLRenderer.h

@@ -1,212 +0,0 @@
-    
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-
-#pragma once
-#include "PolyGlobals.h"
-#include "PolyRenderer.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-#include "PolyGLHeaders.h"
-/*
-#ifdef _WINDOWS 
-#define GL_EXT_framebuffer_object           1
-
-#if GL_EXT_framebuffer_object
-#define GL_FRAMEBUFFER_EXT                 0x8D40
-#define GL_RENDERBUFFER_EXT                0x8D41
-#define GL_STENCIL_INDEX1_EXT              0x8D46
-#define GL_STENCIL_INDEX4_EXT              0x8D47
-#define GL_STENCIL_INDEX8_EXT              0x8D48
-#define GL_STENCIL_INDEX16_EXT             0x8D49
-#define GL_RENDERBUFFER_WIDTH_EXT           0x8D42
-#define GL_RENDERBUFFER_HEIGHT_EXT          0x8D43
-#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44
-#define GL_RENDERBUFFER_RED_SIZE_EXT        0x8D50
-#define GL_RENDERBUFFER_GREEN_SIZE_EXT      0x8D51
-#define GL_RENDERBUFFER_BLUE_SIZE_EXT       0x8D52
-#define GL_RENDERBUFFER_ALPHA_SIZE_EXT      0x8D53
-#define GL_RENDERBUFFER_DEPTH_SIZE_EXT      0x8D54
-#define GL_RENDERBUFFER_STENCIL_SIZE_EXT    0x8D55
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT           0x8CD0
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT           0x8CD1
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT         0x8CD2
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT    0x8CD4
-#define GL_COLOR_ATTACHMENT0_EXT           0x8CE0
-#define GL_COLOR_ATTACHMENT1_EXT           0x8CE1
-#define GL_COLOR_ATTACHMENT2_EXT           0x8CE2
-#define GL_COLOR_ATTACHMENT3_EXT           0x8CE3
-#define GL_COLOR_ATTACHMENT4_EXT           0x8CE4
-#define GL_COLOR_ATTACHMENT5_EXT           0x8CE5
-#define GL_COLOR_ATTACHMENT6_EXT           0x8CE6
-#define GL_COLOR_ATTACHMENT7_EXT           0x8CE7
-#define GL_COLOR_ATTACHMENT8_EXT           0x8CE8
-#define GL_COLOR_ATTACHMENT9_EXT           0x8CE9
-#define GL_COLOR_ATTACHMENT10_EXT          0x8CEA
-#define GL_COLOR_ATTACHMENT11_EXT          0x8CEB
-#define GL_COLOR_ATTACHMENT12_EXT          0x8CEC
-#define GL_COLOR_ATTACHMENT13_EXT          0x8CED
-#define GL_COLOR_ATTACHMENT14_EXT          0x8CEE
-#define GL_COLOR_ATTACHMENT15_EXT          0x8CEF
-#define GL_DEPTH_ATTACHMENT_EXT            0x8D00
-#define GL_STENCIL_ATTACHMENT_EXT          0x8D20
-#define GL_FRAMEBUFFER_COMPLETE_EXT                        0x8CD5
-#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT           0x8CD6
-#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT   0x8CD7
-#define GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT 0x8CD8
-#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT           0x8CD9
-#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT              0x8CDA
-#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT          0x8CDB
-#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT          0x8CDC
-#define GL_FRAMEBUFFER_UNSUPPORTED_EXT                     0x8CDD
-#define GL_FRAMEBUFFER_BINDING_EXT         0x8CA6
-#define GL_RENDERBUFFER_BINDING_EXT        0x8CA7
-#define GL_MAX_COLOR_ATTACHMENTS_EXT       0x8CDF
-#define GL_MAX_RENDERBUFFER_SIZE_EXT       0x84E8
-#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506
-
-#endif
-#endif
-*/
-
-namespace Polycode {
-	class _PolyExport OpenGLRenderer : public Renderer {
-		
-	public:
-		
-		OpenGLRenderer();
-		~OpenGLRenderer();
-
-		bool Init();
-		
-		void Resize(int xRes, int yRes);
-		void BeginRender();
-		void EndRender();
-		
-		Cubemap *createCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5);
-		Texture *createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type = Image::IMAGE_RGBA);
-		void destroyTexture(Texture *texture);		
-		Texture *createFramebufferTexture(unsigned int width, unsigned int height);
-		void createRenderTextures(Texture **colorBuffer, Texture **depthBuffer, int width, int height, bool floatingPointBuffer);
-		
-		void enableAlphaTest(bool val);
-		
-		void createVertexBufferForMesh(Mesh *mesh);
-		void drawVertexBuffer(VertexBuffer *buffer, bool enableColorBuffer);						
-		void bindFrameBufferTexture(Texture *texture);
-		void bindFrameBufferTextureDepth(Texture *texture);		
-		void unbindFramebuffers();
-		
-		Vector2 Project(const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport, const Vector3 &coordiante) const;
-		
-		void cullFrontFaces(bool val);
-				
-		void pushRenderDataArray(RenderDataArray *array);
-		void drawArrays(int drawType, IndexDataArray *indexArray);
-				
-		void setProjectionOrtho(Number xSize=0.0f, Number ySize=0.0f, Number near=-256.0f, Number far=256.0f, bool centered = false);
-        void setProjectionMatrix(Matrix4 matrix);
-		void setPerspectiveDefaults();
-		
-		void enableBackfaceCulling(bool val);
-		
-		void resetViewport();
-		
-		void setLineSmooth(bool val);		
-		
-		void loadIdentity();
-		
-		void setTexture(Texture *texture);		
-
-		Image *renderScreenToImage();
-		Image *renderBufferToImage(Texture *texture);
-		void clearScreen(bool clearColor = true, bool clearDepth = true);
-		
-		void translate2D(Number x, Number y);
-		void rotate2D(Number angle);
-		void scale2D(const Vector2 &scale);
-		
-		void enableScissor(bool val);
-		void setScissorBox(Polycode::Rectangle box);		
-		
-		Vector3 projectRayFrom2DCoordinate(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport);
-		Polycode::Rectangle getViewport();
-		
-		void setLineSize(Number lineSize);
-		void setPointSize(Number pointSize);
-		void setPointSmooth(bool val);
-				
-		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, Number density, Number startDepth, Number endDepth);		
-				
-		void translate3D(const Vector3 &position);
-		void translate3D(Number x, Number y, Number z);
-		void scale3D(const Vector3 &scale);
-		
-		Matrix4 getProjectionMatrix();
-		Matrix4 getModelviewMatrix();		
-		void setModelviewMatrix(Matrix4 m);	
-		void multModelviewMatrix(Matrix4 m);
-		
-        void setWireframePolygonMode(bool val);
-		
-		void enableDepthTest(bool val);
-		void enableDepthWrite(bool val);
-				
-		void setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number near, Number far);
-		void setProjectionFromFoV(Number fov, Number near, Number far);
-
-		void clearBuffer(bool colorBuffer, bool depthBuffer);	
-		void drawToColorBuffer(bool val);
-		
-		void drawScreenQuad(Number qx, Number qy);
-				
-		void pushMatrix();
-		void popMatrix();		
-		
-		Vector3 Unproject(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport);
-		
-		void setDepthFunction(int depthFunction);
-						
-		void clearShader();
-		
-	protected:
-		void initOSSpecific();
-		
-		int verticesToDraw;
-		
-		GLdouble sceneProjectionMatrix[16];
-		GLdouble sceneProjectionMatrixOrtho[16];	
-		
-	};
-}
-

Core/Contents/Include/PolyGLSLProgram.h

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

Core/Contents/Include/PolyGLSLShader.h

@@ -1,54 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "PolyGlobals.h"
-#include "PolyString.h"
-#include "PolyShader.h"
-#include <vector>
-
-namespace Polycode {
-
-	class GLSLProgram;
-
-	class _PolyExport GLSLShader : public Shader {
-		public:
-			GLSLShader(GLSLProgram *vp, GLSLProgram *fp);
-			virtual ~GLSLShader();
-
-			ShaderBinding *createBinding();
-			virtual void reload();
-			
-			void handleEvent(Event *event);
-			
-			static int getPolycodeParamType(int glType);
-			
-			void setVertexProgram(ShaderProgram *vp);
-			void setFragmentProgram(ShaderProgram *fp);			
-				
-			unsigned int shader_id;		
-			
-			void linkProgram();			
-			void unlinkProgram();
-	};	
-}

Core/Contents/Include/PolyGLSLShaderModule.h

@@ -1,57 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "PolyModule.h"
-
-namespace Polycode {
-	
-	class GLSLProgram;
-	class ProgramParam;
-	class GLSLShader;
-	class ShaderProgram;
-    class ResourcePool;
-
-	class _PolyExport GLSLShaderModule : public PolycodeShaderModule {
-		public:
-			GLSLShaderModule();
-			virtual ~GLSLShaderModule();
-		
-			bool acceptsExtension(const String& extension);
-			ShaderProgram* createProgramFromFile(const String& extension, const String& fullPath);
-			void reloadPrograms();
-			String getShaderType();
-			Shader *createShader(ResourcePool *resourcePool, TiXmlNode *node);
-			Shader *createShader(ResourcePool *resourcePool, String name, String vpName, String fpName);
-			bool applyShaderMaterial(Renderer *renderer, Material *material, ShaderBinding *localOptions, unsigned int shaderIndex);	
-			void clearShader();
-		
-	protected:
-		
-		GLSLProgram *createGLSLProgram(const String& fileName, int type);
-		void updateGLSLParam(Renderer *renderer, GLSLShader *glslShader, ProgramParam &param, ShaderBinding *materialOptions, ShaderBinding *localOptions);			
-		
-		std::vector<GLSLProgram*> programs;
-	};
-	
-}

Core/Contents/Include/PolyGLTexture.h

@@ -1,73 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
- 
-#pragma once
-#include "PolyGlobals.h"
-#include "PolyTexture.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-#if defined(__APPLE__) && defined(__MACH__)
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#include <OpenGL/glu.h>	
-#else
-#include <GL/gl.h>
-#include <GL/glext.h>
-#include <GL/glu.h>
-#endif
-
-#define FRAMEBUFFER_NULL 999999
-
-namespace Polycode {
-
-	class _PolyExport OpenGLTexture : public Texture {
-		public:
-			OpenGLTexture(unsigned int width, unsigned int height);
-			OpenGLTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int filteringMode, int type);
-			virtual ~OpenGLTexture();
-			
-			void recreateFromImageData();
-
-			GLuint getTextureID();
-			GLuint getFrameBufferID();
-			
-			void setGLInfo(GLuint textureID, GLuint frameBufferID);
-			
-			void setTextureData(char *data);
-			
-		private:
-			
-			bool glTextureLoaded;
-			GLenum glTextureType;
-			GLuint glTextureFormat;
-			GLenum pixelType;
-			
-			int filteringMode;
-			GLuint textureID;
-			GLuint frameBufferID;
-	};
-
-}

Core/Contents/Include/PolyGPUDrawBuffer.h

@@ -0,0 +1,65 @@
+/*
+ Copyright (C) 2015 by Ivan Safrin
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+#pragma once
+
+#include "PolyMesh.h"
+#include "PolyShader.h"
+#include "PolyRectangle.h"
+
+namespace Polycode {
+    
+    class _PolyExport GPUDrawOptions {
+    public:
+        bool depthTest;
+        bool depthWrite;
+        float linePointSize;
+        bool alphaTest;
+        bool backfaceCull;
+        bool depthOnly;
+        Color drawColor;
+    };
+    
+    class _PolyExport GPUDrawCall {
+    public:
+        unsigned int numVertices;
+        unsigned char type;
+        bool ownsAttributes;
+        GPUDrawOptions options;
+        
+        Matrix4 modelMatrix;
+        
+        std::vector<RenderDataArray*> attributeArrays;
+        std::vector<LocalShaderParam> uniforms;
+    };
+    
+    
+    class _PolyExport GPUDrawBuffer {
+    public:
+        GPUDrawBuffer();
+        ~GPUDrawBuffer();
+        
+        Matrix4 projectionMatrix;        
+        Polycode::Rectangle viewport;
+        std::vector<GPUDrawCall> drawCalls;
+    };
+}

Core/Contents/Include/PolyMaterialManager.h

@@ -33,7 +33,6 @@ namespace Polycode {
 	
 	class Cubemap;
 	class Material;
-	class PolycodeShaderModule;
 	class Texture;
 	class SceneRenderTexture;
 	class Shader;
@@ -51,10 +50,6 @@ namespace Polycode {
 			
 			void Update(int elapsed);
 
-			/**
-			* Creates a new framebuffer texture.
-			*/ 
-			Texture *createFramebufferTexture(int width, int height, int type);
 			Texture *createTexture(int width, int height, char *imageData, bool clamp=false, bool createMipmaps = true, int type=Image::IMAGE_RGBA);
 			Texture *createNewTexture(int width, int height, bool clamp=false, bool createMipmaps = true, int type=Image::IMAGE_RGBA);
 			Texture *createTextureFromImage(Image *image, bool clamp=false, bool createMipmaps = true);
@@ -64,9 +59,7 @@ namespace Polycode {
 			void reloadTextures();
 			
 			void reloadProgramsAndTextures();
-			void reloadPrograms();		
-		
-			void addShaderModule(PolycodeShaderModule *module);		
+			void reloadPrograms();
 		
 			//SceneRenderTexture *createRenderTexture(Scene *targetScene, Camera *targetCamera, int renderWidth,int renderHeight);
 			Texture *getTextureByResourcePath(const String& resourcePath) const;
@@ -107,7 +100,6 @@ namespace Polycode {
 			std::vector<Texture*> textures;
 			std::vector<Material*> materials;
 			std::vector<Shader*> shaders;
-		
-			std::vector <PolycodeShaderModule*> shaderModules;
+
 	};
 };

Core/Contents/Include/PolyMatrix4.h

@@ -319,7 +319,25 @@ namespace Polycode {
 			 * @param n The number of dimensions in matrix A.
 			 */
 			static Number generalDeterminant(Number const* const*a, int n);
-		
+        
+            // projection stuff
+        
+            inline void setOrthoProjection(Number left, Number right, Number bottom, Number top, Number zNear, Number zFar) {
+                m[0][0] = 2.0/(right-left);
+                m[1][1] = 2.0/(top-bottom);
+                m[2][2] = -2.0/(zFar-zNear);
+            }
+
+            inline void setProjection(Number fov, Number aspect, Number zNear, Number zFar) {
+                m[0][0] = 1.0f/tanf(fov/2.0)/aspect;
+                m[1][1] = 1.0f/tanf(fov/2.0);
+                m[2][2] = (zFar+zNear)/(zNear-zFar);
+                m[3][2] = (2.0f*zFar*zNear)/(zNear-zFar);
+                m[2][3] = -1.0f;
+                m[3][3] = 0.0f;
+            }
+        
+        
 		protected:
 		
 	};

Core/Contents/Include/PolyModule.h

@@ -1,64 +0,0 @@
-/*
- *  PolyModule.h
- *  PolyCore
- *
- *  Created by Ivan Safrin on 12/1/10.
- *  Copyright 2010 Local Projects. All rights reserved.
- *
- */
-
-#pragma once
-#include "PolyString.h"
-#include "PolyGlobals.h"
-
-class TiXmlNode;
-
-namespace Polycode {
-	
-	class Material;
-	class Renderer;
-	class Shader;
-	class ShaderBinding;
-	class Resource;
-	class ShaderProgram;
-    class ResourcePool;
-	
-	class _PolyExport PolycodeModule : public PolyBase {
-	public:
-		PolycodeModule();
-		virtual ~PolycodeModule();
-		
-		int getType() { return type; }
-		
-		static const int TYPE_GENERIC = 0;
-		static const int TYPE_SHADER = 1;
-		
-		virtual void Update(Number elapsed) {}
-		
-		bool requiresUpdate();
-		
-	protected:
-		int type;
-		bool _requiresUpdate;
-	};
-	
-	class _PolyExport PolycodeShaderModule : public PolycodeModule {
-	public:
-		PolycodeShaderModule();
-		virtual ~PolycodeShaderModule();
-		
-		virtual bool acceptsExtension(const String& extension) = 0;
-		virtual ShaderProgram* createProgramFromFile(const String& extension, const String& fullPath) = 0;
-		virtual String getShaderType() = 0;
-		virtual Shader *createShader(ResourcePool *resourcePool, TiXmlNode *node) = 0;
-		virtual Shader *createShader(ResourcePool *resourcePool, String name, String vpName, String fpName) = 0;
-			
-		virtual bool applyShaderMaterial(Renderer *renderer, Material *material, ShaderBinding *localOptions, unsigned int shaderIndex) = 0;
-		bool hasShader(Shader *shader) { for(int i=0; i < shaders.size(); i++) { if(shaders[i] == shader){ return true; } } return false; }	
-		virtual void clearShader() = 0;
-		virtual void reloadPrograms() = 0;
-	protected:
-		std::vector<Shader*> shaders;
-	};
-	
-}

Core/Contents/Include/PolyGLVertexBuffer.h → Core/Contents/Include/PolyOpenGLGraphicsInterface.h

@@ -1,5 +1,6 @@
+    
 /*
-Copyright (C) 2011 by Ivan Safrin
+Copyright (C) 2015 by Ivan Safrin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +23,9 @@ THE SOFTWARE.
 
 
 #pragma once
-#include "PolyMesh.h"
+#include "PolyGlobals.h"
+#include "PolyRenderer.h"
+#include "PolyTexture.h"
 
 #ifdef _WINDOWS
 #include <windows.h>
@@ -34,37 +37,33 @@ THE SOFTWARE.
 #include <OpenGL/glu.h>
 #else
 #include <GL/gl.h>
+#include <GL/glu.h>
 #include <GL/glext.h>
+
+#if defined(_WINDOWS) && !defined(_MINGW)
+#include <GL/wglext.h>
+#endif
 #endif
 
+
 namespace Polycode {
-	
-	class _PolyExport OpenGLVertexBuffer : public VertexBuffer {
-	public:
+	class _PolyExport OpenGLGraphicsInterface : public GraphicsInterface {
 		
-		explicit OpenGLVertexBuffer(Mesh *mesh);
-		virtual ~OpenGLVertexBuffer();
+	public:
 		
-		GLuint getVertexBufferID();		
-		GLuint getTextCoordBufferID();	
-		GLuint getNormalBufferID();
-		GLuint getColorBufferID();
-		GLuint getTangentBufferID();
-		GLuint getIndexBufferID();
-		GLuint getBoneWeightBufferID();
-		GLuint getBoneIndexBufferID();
+		OpenGLGraphicsInterface();
+		~OpenGLGraphicsInterface();
+
+		// implementation
+        
+        void executeDrawCall(const GPUDrawCall& drawCall);
+        void createTexture(Texture *texture, int filteringMode, int anisotropy, bool createMipmaps);
+        void setViewport(unsigned int x,unsigned  int y,unsigned  int width, unsigned height);
+        void clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer);
         
 	protected:
 		
-		GLuint vertexBufferID;
-		GLuint texCoordBufferID;
-		GLuint normalBufferID;
-		GLuint colorBufferID;	
-		GLuint tangentBufferID;
-        GLuint indexBufferID;
         
-        GLuint boneWeightBufferID;
-        GLuint boneIndexBufferID;
 	};
-	
 }
+

Core/Contents/Include/PolyRenderer.h

@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2011 by Ivan Safrin
+Copyright (C) 2015 by Ivan Safrin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -28,339 +28,111 @@ THE SOFTWARE.
 #include "PolyShader.h"
 #include "PolyImage.h"
 #include "PolyRectangle.h"
+#include "PolyShader.h"
+#include "PolyRenderDataArray.h"
+#include "PolyThreaded.h"
+#include "PolyGPUDrawBuffer.h"
 #include <stack>
+#include <queue>  
 
 namespace Polycode {
-	
-	class Cubemap;
-	class Material;
-	class Mesh;
-	class PolycodeShaderBinding;
-	class PolycodeShaderModule;
-	class Polygon;
-	class RenderDataArray;
-    class IndexDataArray;
-	class ShaderBinding;
-	class Texture;
-	class VertexBuffer;
-
-	class _PolyExport LightInfo : public PolyBase {
-		public:
-			Vector3 position;
-			Vector3 color;
-			Color specularColor;
-			Vector3 dir;
-			Number constantAttenuation;
-			Number linearAttenuation;
-			Number quadraticAttenuation;			
-			Number intensity;
-			Number spotlightCutoff;
-			Number spotlightExponent;			
-			int type;
-			bool shadowsEnabled;
-			Matrix4 textureMatrix;
-			Texture* shadowMapTexture;
-			int lightImportance;
-	};
-
-	class _PolyExport LightSorter : public PolyBase {
-		public:
-			Vector3 basePosition;
-			bool operator() (LightInfo i,LightInfo j) {                
-				if(i.lightImportance > j.lightImportance)
-					return true;
-				if(i.lightImportance == j.lightImportance)
-					return i.position.distance(basePosition) < j.position.distance(basePosition);
-				return false; 
-			}
-	};
-
-	/**
-	* Provides low-level settings for the main renderer.
-	*
-	* The methods and settings in this class are closely related to OpenGL.
-	* If you have trouble understanding anything in this class, it is thus suggested to brush up on your OpenGL knowledge.
-	*
-	* The renderer should only be accessed from the CoreServices singleton. Renderer operations should only be called from within Render methods of entities so that they can be properly managed.
-	*
-	*/
-	class _PolyExport Renderer : public PolyBase {
+    
+    class _PolyExport GraphicsInterface : public PolyBase {
+        public:
+            GraphicsInterface();
+            virtual void executeDrawCall(const GPUDrawCall& drawCall) = 0;
+            virtual void createTexture(Texture *texture, int filteringMode, int anisotropy, bool createMipmaps) = 0;
+            virtual void setViewport(unsigned int x,unsigned  int y,unsigned  int width, unsigned height) = 0;
+            virtual void clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer) = 0;
+        
+        protected:
+        
+    };
+    
+    class _PolyExport RendererThreadJob {
+        public:
+            int jobType;
+            void *data;
+    };
+    
+    class _PolyExport RendererOptions {
+        public:
+        
+        int filteringMode;
+        int anisotropy;
+        bool createMipmaps;
+    };
+    
+    class _PolyExport RenderThread : public Threaded {
+        public:
+            RenderThread();
+            void setGraphicsInterface(Core *core, GraphicsInterface *interface);
+            virtual void runThread();
+            void enqueueJob(int jobType, void *data);
+            void processJob(const RendererThreadJob &job);
+        
+            static const int JOB_REQUEST_CONTEXT_CHANGE = 0;
+            static const int JOB_CREATE_TEXTURE = 1;
+            static const int JOB_PROCESS_DRAW_BUFFER = 2;
+            static const int JOB_FLUSH_CONTEXT = 3;
+        
+        protected:
+            Core *core;
+            RendererOptions options;
+            CoreMutex *jobQueueMutex;
+            std::queue<RendererThreadJob> jobQueue;
+            GraphicsInterface *interface;
+    };
+    
+    class _PolyExport Renderer : public PolyBase {
 	public:
+        
 		Renderer();
 		virtual ~Renderer();
-		
-		virtual bool Init();
-
-		virtual void Resize(int xRes, int yRes) = 0;
-		
-        virtual void BeginRender();
-        virtual void EndRender();
-		
-		virtual Cubemap *createCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) = 0;		
-		virtual Texture *createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type=Image::IMAGE_RGBA) = 0;
-		virtual void destroyTexture(Texture *texture) = 0;
-		virtual void createRenderTextures(Texture **colorBuffer, Texture **depthBuffer, int width, int height, bool floatingPointBuffer) = 0;
-		
-		virtual Texture *createFramebufferTexture(unsigned int width, unsigned int height) = 0;
-		virtual void bindFrameBufferTexture(Texture *texture);
-		virtual void bindFrameBufferTextureDepth(Texture *texture);
-		virtual void unbindFramebuffers();
-
-		virtual Image *renderScreenToImage() = 0;
-		virtual Image *renderBufferToImage(Texture *texture) = 0;
-		
-		void setViewportSize(int w, int h);
-		virtual void resetViewport() = 0;
-		
-		virtual Polycode::Rectangle getViewport() = 0;
-				
-		virtual void loadIdentity() = 0;		
-		virtual void setProjectionOrtho(Number xSize=0.0f, Number ySize=0.0f, Number near=-256.0f, Number far=256.0f, bool centered = false) = 0;
-		virtual void setPerspectiveDefaults() = 0;
-        virtual void setProjectionMatrix(Matrix4 matrix) = 0;
-		
-		virtual void setTexture(Texture *texture) = 0;		
-		virtual void enableBackfaceCulling(bool val) = 0;
-		
-		virtual void setClearColor(Number r, Number g, Number b, Number a = 1.0);
-		virtual void setClearColor(Color color);
-		
-		virtual void setAmbientColor(Number r, Number g, Number b);
-		
-		virtual void clearScreen(bool clearColor = true, bool clearDepth = true) = 0;
-		
-		virtual void translate2D(Number x, Number y) = 0;
-		virtual void rotate2D(Number angle) = 0;
-		virtual void scale2D(const Vector2 &scale) = 0;
-			
-		
-		virtual void setVertexColor(Number r, Number g, Number b, Number a) = 0;
-				
-		virtual void pushRenderDataArray(RenderDataArray *array) = 0;
-		virtual void drawArrays(int drawType, IndexDataArray *indexArray) = 0;
-		
-		virtual void translate3D(const Vector3 &position) = 0;
-		virtual void translate3D(Number x, Number y, Number z) = 0;
-		virtual void scale3D(const Vector3 &scale) = 0;
-		
-		virtual void pushMatrix() = 0;
-		virtual void popMatrix() = 0;
-		
-		virtual void setLineSmooth(bool val) = 0;
-		virtual void setLineSize(Number lineSize) = 0;
-		virtual void setPointSize(Number pointSize) = 0;
-		virtual void setPointSmooth(bool val) = 0;
-				
-		virtual void enableLighting(bool enable) = 0;
-			
-		virtual void enableFog(bool enable) = 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;
-				
-		virtual void setBlendingMode(int blendingMode) = 0;	
-			
-		virtual void applyMaterial(Material *material, ShaderBinding *localOptions, unsigned int shaderIndex, bool forceMaterial);
-		virtual void clearShader() = 0;
-		
-		virtual void setDepthFunction(int depthFunction) = 0;
-				
-		virtual void createVertexBufferForMesh(Mesh *mesh) = 0;
-		virtual void drawVertexBuffer(VertexBuffer *buffer, bool enableColorBuffer) = 0;
-		
-		virtual void enableDepthTest(bool val) = 0;
-		virtual void enableDepthWrite(bool val) = 0;
-        virtual void setWireframePolygonMode(bool val) = 0;
-		
-		void billboardMatrix();
-		void billboardMatrixWithScale(Vector3 scale);
-		
-		void setTextureFilteringMode(int mode);
-
-		/**
-		 * Set the frustum clipping planes.
-		 *
-		 * Please check the supplied external links for more information
-		 * about the problems of a high farPlane/nearPlane setting.
-		 *
-		 * @see http://www.opengl.org/sdk/docs/man2/xhtml/glFrustum.xml
-		 */
-		virtual void setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number front, Number back) = 0;
-
-
-		virtual void setProjectionFromFoV(Number fov, Number near, Number far) = 0;
-
-		/**
-		 * Enable/disable alpha tests.
-		 *
-		 * If alpha tests are enabled, drawn pixels of textures will
-		 * be "mixed" with framebuffer pixels based on the drawn pixel's
-		 * alpha value. If alpha tests are disabled, they will be drawn
-		 * as solid color.
-		 *
-		 * @param val Whether to enable or disable alpha tests.
-		 */
-		virtual void enableAlphaTest(bool val) = 0;
-		
-		virtual void clearBuffer(bool colorBuffer, bool depthBuffer) = 0;
-		virtual void drawToColorBuffer(bool val) = 0;
-		
-		const Matrix4& getCameraMatrix() const;
-		void setCameraMatrix(const Matrix4& matrix);
-		
-		virtual void drawScreenQuad(Number qx, Number qy) = 0;
-		
-		int getXRes();
-		int getYRes();
-		
-		bool isScissorEnabled();
-		
-		virtual void enableScissor(bool val);
-		virtual void setScissorBox(Polycode::Rectangle box);
-		
-		Polycode::Rectangle getScissorBox();
-		
-		void setAnisotropyAmount(Number amount);
-		Number getAnisotropyAmount();
-		
-		virtual void cullFrontFaces(bool val) = 0;
-		
-		void clearLights();
-		void addLight(int lightImportance, const Vector3 &position, const Vector3 &direction, int type, const Color &color, const Color &specularColor, Number constantAttenuation, Number linearAttenuation, Number quadraticAttenuation, Number intensity, Number spotlightCutoff, Number spotlightExponent, bool shadowsEnabled, Matrix4 *textureMatrix, Texture *shadowMapTexture);
-		
-		void setExposureLevel(Number level);
-		
-		virtual Vector3 projectRayFrom2DCoordinate(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport) = 0;
-		
-		virtual Vector2 Project(const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport, const Vector3 &coordiante) const = 0;
-		
-		void enableShaders(bool flag);
-		
-		Number getViewportWidth();
-		Number getViewportHeight();		
-		
-		void setViewportShift(Number shiftX, Number shiftY);
-		
-		void *getDataPointerForName(const String &name);
-		void setRendererShaderParams(Shader *shader, ShaderBinding *binding);
-		
-		void addShaderModule(PolycodeShaderModule *module);
-				
-		virtual Matrix4 getProjectionMatrix() = 0;
-		virtual Matrix4 getModelviewMatrix() = 0;
+        void setGraphicsInterface(Core *core, GraphicsInterface *interface);
+        
+        RenderThread *getRenderThread();
 
-        static const int BLEND_MODE_NONE = 0;
-		static const int BLEND_MODE_NORMAL = 1;
-		static const int BLEND_MODE_LIGHTEN = 2;
-		static const int BLEND_MODE_COLOR = 3;
-		static const int BLEND_MODE_PREMULTIPLIED = 4;
-		static const int BLEND_MODE_MULTIPLY = 5;
-								
-		static const int FOG_LINEAR = 0;
-		static const int FOG_EXP = 1;
-		static const int FOG_EXP2 = 2;
-		
-		static const int DEPTH_FUNCTION_GREATER = 0;
-		static const int DEPTH_FUNCTION_LEQUAL = 1;	
-		
-		static const int TEX_FILTERING_NEAREST = 0;
-		static const int TEX_FILTERING_LINEAR = 1;
-		
-		
-		virtual Vector3 Unproject(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport) = 0;
-		
-		Color	ambientColor;
-		Color	clearColor;		
-		Number exposureLevel;		
-		Vector3 cameraPosition;
-		
-		void sortLights();
-		
-		int getNumPointLights() { return numPointLights; }
-		int getNumSpotLights() { return numSpotLights; }
-		int getNumLights() { return numLights; }
-		
-		std::vector<LightInfo> getPointLights() { return pointLights; }
-		std::vector<LightInfo> getSpotLights() { return spotLights;	}
-		
-		bool doClearBuffer;
-		
-		bool blendNormalAsPremultiplied;
-		Number alphaTestValue;
+        Cubemap *createCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5);
+        Texture *createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type=Image::IMAGE_RGBA);
+        void destroyTexture(Texture *texture);
+        void createRenderTextures(Texture **colorBuffer, Texture **depthBuffer, int width, int height, bool floatingPointBuffer);
         
-        void setBackingResolutionScale(Number xScale, Number yScale);
+        void processDrawBuffer(GPUDrawBuffer *buffer);
         
+        void setBackingResolutionScale(Number xScale, Number yScale);
         Number getBackingResolutionScaleX();
         Number getBackingResolutionScaleY();
         
-        void setOverrideMaterial(Material *material);
+        void setAnisotropyAmount(Number amount);
+        Number getAnisotropyAmount();
         
-        void pushVertexColor();
-        void popVertexColor();
-        void loadVertexColorIdentity();
-        void multiplyVertexColor(const Color &color);
+        void flushContext();
         
-        void setRenderToGlobalFramebuffer(bool val);
-        bool getRenderToGlobalFramebuffer() const;
+        static const int BLEND_MODE_NONE = 0;
+        static const int BLEND_MODE_NORMAL = 1;
+        static const int BLEND_MODE_LIGHTEN = 2;
+        static const int BLEND_MODE_COLOR = 3;
+        static const int BLEND_MODE_PREMULTIPLIED = 4;
+        static const int BLEND_MODE_MULTIPLY = 5;
         
-        Texture *getGlobalColorFramebuffer() const;
-        Texture *getGlobalDepthFramebuffer() const;
+        static const int DEPTH_FUNCTION_GREATER = 0;
+        static const int DEPTH_FUNCTION_LEQUAL = 1;
         
-	protected:
-		virtual void initOSSpecific() {};
+        static const int TEX_FILTERING_NEAREST = 0;
+        static const int TEX_FILTERING_LINEAR = 1;
         
+        
+	protected:
+      
         Number backingResolutionScaleX;
         Number backingResolutionScaleY;
         
-        std::stack<Color> vertexColorStack;
-        Color currentVertexColor;
-        
-        std::stack<Texture*> framebufferStackColor;
-        std::stack<Texture*> framebufferStackDepth;
-        
-		bool scissorEnabled;
-		
-		Polycode::Rectangle scissorBox;
-	
 		Number anisotropy;
-		LightSorter sorter;	
-	
-		Number viewportWidth;
-		Number viewportHeight;
-		
-		Vector2 viewportShift;
-			
-		bool cullingFrontFaces;
-				
-		Texture *currentTexture;
-		Material *currentMaterial;
-		
-		int textureFilteringMode;
-		
-		Matrix4 cameraMatrix;
-        Material *overrideMaterial;
-        
-		PolycodeShaderModule* currentShaderModule;
-		std::vector <PolycodeShaderModule*> shaderModules;
         
-        bool renderToGlobalFramebuffer;
-        Texture *globalColorFramebuffer;
-        Texture *globalDepthFramebuffer;
+        int cpuBufferIndex;
+        int gpuBufferIndex;
+        RenderThread *renderThread;
 
-		std::vector<LightInfo> lights;
-		std::vector<LightInfo> pointLights;
-		std::vector<LightInfo> spotLights;
-		int numLights;
-		int numPointLights;
-		int numSpotLights;
-		
-		bool shadersEnabled;
-		Number fov;
-				
-		bool lightingEnabled;
-	
-		int xRes;
-		int yRes;
 	};
 }

Core/Contents/Include/PolySceneLabel.h

@@ -46,7 +46,7 @@ namespace Polycode {
             void setLabelActualHeight(Number actualHeight);
             Number getLabelActualHeight();
 			
-			void Render();
+			void Render(GPUDrawBuffer *buffer);
 
             int getTextWidthForString(String text);
         

Core/Contents/Include/PolySceneManager.h

@@ -22,6 +22,7 @@ THE SOFTWARE.
 
 #pragma once
 #include "PolyGlobals.h"
+#include "PolyRectangle.h"
 
 #include <vector>
 
@@ -52,7 +53,7 @@ namespace Polycode {
         // Polycode internal
 		void Update();
 		void fixedUpdate();
-		void Render();
+		void Render(const Polycode::Rectangle &viewport);
 		void renderVirtual();
 		void registerRenderTexture(SceneRenderTexture *renderTexture);
 		void unregisterRenderTexture(SceneRenderTexture *renderTexture);

Core/Contents/Include/PolySceneMesh.h

@@ -25,6 +25,7 @@ THE SOFTWARE.
 #include "PolyEntity.h"
 #include "PolyShader.h"
 #include "PolyRenderDataArray.h"
+#include "PolyRenderer.h"
 
 namespace Polycode {
 
@@ -71,7 +72,7 @@ namespace Polycode {
 						
 			virtual ~SceneMesh();
 			
-			void Render();
+			void Render(GPUDrawBuffer *buffer);
 			
             /**
              * Returns the local material binding options for this mesh.
@@ -150,11 +151,6 @@ namespace Polycode {
 		
 			void renderMeshLocally();
 			
-			/**
-			* If this is set to true, the mesh will be cached to a hardware vertex buffer if those are available. This can dramatically speed up rendering.
-			*/
-			void cacheToVertexBuffer(bool cache);
-			
             /**
              * Sets the line width for line-based meshes.
              */

Core/Contents/Include/PolySceneSprite.h

@@ -178,7 +178,7 @@ namespace Polycode {
         void setCurrentFrame(unsigned int frameIndex);
         unsigned int getCurrentFrame();
         void Update();
-        void Render();
+        void Render(GPUDrawBuffer *buffer);
         
         Vector3 getSpriteBoundingBox() const;
         

Core/Contents/Include/PolyTexture.h

@@ -37,18 +37,9 @@ namespace Polycode {
 			Number scrollSpeedX;
 			Number scrollSpeedY;
 			
-			void reloadResource();			
-			
-			virtual void setTextureData(char *data) = 0;
-
-			virtual void recreateFromImageData() = 0;
-
-			Number getScrollOffsetX() const;
-			Number getScrollOffsetY() const;
+			void reloadResource();
 			
 			void setImageData(Image *data);
-		
-			void updateScroll(int elapsed);		
 			char *getTextureData() const { return textureData;}
 			
 			int getWidth() const;
@@ -59,7 +50,10 @@ namespace Polycode {
 		
 			bool clamp;
 			char *textureData;
-					
+        
+            void *platformData;
+            int type;
+        
 		protected:
 
 			int pixelSize;

Core/Contents/Source/PolyCamera.cpp

@@ -163,7 +163,7 @@ void Camera::buildFrustumPlanes() {
 	Matrix4 mvp;
 	Number t;
 
-    mv = renderer->getModelviewMatrix();
+   // mv = renderer->getModelviewMatrix();
 
     //
     // Concatenate the projection matrix and the model-view matrix to produce 
@@ -342,6 +342,9 @@ void Camera::removePostFilter() {
 }
 
 void Camera::setPostFilter(Material *shaderMaterial) {
+    
+    // RENDERER_TODO
+    /*
 	if(!shaderMaterial)
 		return;
 	if(shaderMaterial->getNumShaders() == 0)
@@ -359,6 +362,7 @@ void Camera::setPostFilter(Material *shaderMaterial) {
 	}
 
 	_hasFilterShader = true;
+     */
 }
 
 bool Camera::hasFilterShader() {
@@ -367,6 +371,8 @@ bool Camera::hasFilterShader() {
 
 void Camera::drawFilter(Texture *targetTexture, Number targetTextureWidth, Number targetTextureHeight, Texture *targetColorTexture, Texture *targetZTexture) {
 
+    // RENDERER_TODO
+/*
 	if(!filterShaderMaterial)
 		return;
 		
@@ -430,8 +436,8 @@ void Camera::drawFilter(Texture *targetTexture, Number targetTextureWidth, Numbe
 					renderer->bindFrameBufferTexture(targetTexture);								
 					renderer->clearScreen();
 					renderer->loadIdentity();
-
-					renderer->drawScreenQuad(targetTextureWidth, targetTextureHeight);
+                    // RENDERER_TODO
+					//renderer->drawScreenQuad(targetTextureWidth, targetTextureHeight);
 					renderer->unbindFramebuffers();									
 				} else {
                     // global framebuffer ONLY used for input
@@ -444,15 +450,18 @@ void Camera::drawFilter(Texture *targetTexture, Number targetTextureWidth, Numbe
 					renderer->setViewportSize(renderer->getXRes(), renderer->getYRes());
 					renderer->clearScreen();
 					renderer->loadIdentity();
-					renderer->drawScreenQuad(renderer->getXRes(), renderer->getYRes());
+                    // RENDERER_TODO
+
+					//renderer->drawScreenQuad(renderer->getXRes(), renderer->getYRes());
 				}
 		} else {
 			for(int j=0; j < materialBinding->getNumOutTargetBindings(); j++) {
 				Texture *bindingTexture = materialBinding->getOutTargetBinding(j)->texture;
 				if(bindingTexture) {
 					renderer->setViewportSize(bindingTexture->getWidth(), bindingTexture->getHeight());
-					renderer->bindFrameBufferTexture(bindingTexture);				
-					renderer->drawScreenQuad(bindingTexture->getWidth(), bindingTexture->getHeight());
+					renderer->bindFrameBufferTexture(bindingTexture);
+                    // RENDERER_TODO
+					//renderer->drawScreenQuad(bindingTexture->getWidth(), bindingTexture->getHeight());
 					renderer->unbindFramebuffers();
 				}
 			}		
@@ -460,6 +469,7 @@ void Camera::drawFilter(Texture *targetTexture, Number targetTextureWidth, Numbe
 		renderer->clearShader();
 		renderer->loadIdentity();
 	}
+ */
 }
 
 Matrix4 Camera::getProjectionMatrix() {
@@ -470,6 +480,10 @@ Polycode::Rectangle Camera::getViewport() {
 	return viewport;
 }
 
+void Camera::setViewport(const Polycode::Rectangle &viewport) {
+    this->viewport = viewport;
+}
+
 Number Camera::getNearClippingPlane() {
     return nearClipPlane;
 }
@@ -486,19 +500,57 @@ void Camera::setProjectionMatrix(Matrix4 matrix) {
     projectionMatrix = matrix;
 }
 
-void Camera::doCameraTransform() {
-	
+void Camera::setOrthoMatrix(Matrix4 &matrix, Number xSize, Number ySize, Number _near, Number _far, bool centered) {
+
+    if(centered) {
+        matrix.setOrthoProjection(-xSize*0.5, xSize*0.5, -ySize*0.5, ySize*0.5, _near, _far);
+    } else {
+        matrix.setOrthoProjection(0.0f, xSize, 0, ySize, _near, _far);
+    }
+}
+
+Matrix4 Camera::createProjectionMatrix() {
+    
+    Matrix4 retMatrix;
+    
+    switch (projectionMode) {
+        case PERSPECTIVE_FOV:
+            retMatrix.setProjection(fov * TORADIANS, (viewport.w/viewport.h), nearClipPlane, farClipPlane);
+            break;
+        case PERSPECTIVE_FRUSTUM:
+            // TODO
+          //  renderer->setProjectionFromFrustum(leftFrustum, rightFrustum, bottomFrustum, topFrustum, nearClipPlane, farClipPlane);
+            break;
+        case ORTHO_SIZE_MANUAL:
+            setOrthoMatrix(retMatrix, orthoSizeX, orthoSizeY, nearClipPlane, farClipPlane, !topLeftOrtho);
+            break;
+        case ORTHO_SIZE_LOCK_HEIGHT:
+            setOrthoMatrix(retMatrix, orthoSizeY * (viewport.w/viewport.h), orthoSizeY, nearClipPlane, farClipPlane, !topLeftOrtho);
+            break;
+        case ORTHO_SIZE_LOCK_WIDTH:
+            setOrthoMatrix(retMatrix, orthoSizeX, orthoSizeX * (viewport.h/viewport.w), nearClipPlane, farClipPlane, !topLeftOrtho);
+            break;
+        case ORTHO_SIZE_VIEWPORT:
+            setOrthoMatrix(retMatrix, viewport.w / renderer->getBackingResolutionScaleX(), viewport.h / renderer->getBackingResolutionScaleY(), nearClipPlane, farClipPlane, !topLeftOrtho);
+            break;
+        case MANUAL_MATRIX:
+            retMatrix = projectionMatrix;
+            break;
+    }
+    
+    return retMatrix;
+    
+    // RENDERER_TODO
+	/*
     viewport = renderer->getViewport();
 
 	switch (projectionMode) {
 		case PERSPECTIVE_FOV:
 			renderer->setViewportShift(cameraShift.x, cameraShift.y);
 			renderer->setProjectionFromFoV(fov, nearClipPlane, farClipPlane);
-			renderer->setPerspectiveDefaults();
 		break;
 		case PERSPECTIVE_FRUSTUM:
 			renderer->setProjectionFromFrustum(leftFrustum, rightFrustum, bottomFrustum, topFrustum, nearClipPlane, farClipPlane);
-			renderer->setPerspectiveDefaults();
 		break;
 		case ORTHO_SIZE_MANUAL:
 			renderer->setProjectionOrtho(orthoSizeX, orthoSizeY, nearClipPlane, farClipPlane, !topLeftOrtho);
@@ -530,4 +582,5 @@ void Camera::doCameraTransform() {
 	renderer->setCameraMatrix(camMatrix);	
 	camMatrix = camMatrix.Inverse();
 	renderer->multModelviewMatrix(camMatrix);
+     */
 }

Core/Contents/Source/PolyCocoaCore.mm

@@ -107,15 +107,10 @@ CocoaCore::CocoaCore(PolycodeView *view, int _xRes, int _yRes, bool fullScreen,
 	
 	initTime = mach_absolute_time();					
 
-	modeChangeInfo.needResolutionChange = false;
-
-	renderer = new OpenGLRenderer();
-	services->setRenderer(renderer);			
-	_setVideoMode(xRes,yRes,fullScreen, vSync, aaLevel, anisotropyLevel);
-	renderer->Init();
-
-	CoreServices::getInstance()->installModule(new GLSLShaderModule());	
-
+    renderer = new Renderer();
+    renderer->setGraphicsInterface(this, new OpenGLGraphicsInterface());
+    services->setRenderer(renderer);
+    setVideoMode(xRes, yRes, fullScreen, vSync, aaLevel, anisotropyLevel, retinaSupport);
 }
 
 void CocoaCore::copyStringToClipboard(const String& str) {
@@ -125,12 +120,6 @@ void CocoaCore::copyStringToClipboard(const String& str) {
     [pb declareTypes:types owner:nil];
 	
 	NSString *nsstr = [NSString stringWithCString: str.c_str() encoding:NSUTF8StringEncoding];
-	/*
-	char* data = (char*)str.c_str();
-	unsigned size = str.size() * sizeof(char);
-	
-	NSString* nsstr = [[[NSString alloc] initWithBytes:data length:size encoding:NSUTF32LittleEndianStringEncoding] autorelease];
-	*/
     [pb setString: nsstr forType:NSStringPboardType];	
 }
 
@@ -140,18 +129,6 @@ String CocoaCore::getClipboardString() {
 	return [retString UTF8String];
 }
 
-void CocoaCore::setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, bool retinaSupport) {
-    this->retinaSupport = retinaSupport;
-	// hack to make sure there are no window race conditions
-	modeChangeInfo.needResolutionChange = true;
-	modeChangeInfo.xRes = xRes;
-	modeChangeInfo.yRes = yRes;
-	modeChangeInfo.fullScreen = fullScreen;
-	modeChangeInfo.vSync = vSync;
-	modeChangeInfo.aaLevel = aaLevel;
-	modeChangeInfo.anisotropyLevel = anisotropyLevel;	
-}
-
 Number CocoaCore::getBackingXRes() {
     if(!retinaSupport) {
         return getXRes();
@@ -168,10 +145,11 @@ Number CocoaCore::getBackingYRes() {
     return backingBounds.size.height;
 }
 
-void CocoaCore::_setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel) {
-	this->xRes = xRes;
-	this->yRes = yRes;
-
+void CocoaCore::handleVideoModeChange(VideoModeChangeInfo *modeInfo) {
+	this->xRes = modeInfo->xRes;
+	this->yRes = modeInfo->yRes;
+    this->retinaSupport = modeInfo->retinaSupport;
+    
     NSRect backingBounds;
     if(retinaSupport) {
         [glView setWantsBestResolutionOpenGLSurface:YES];
@@ -186,8 +164,9 @@ void CocoaCore::_setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, i
     }
     
 	bool _wasFullscreen = this->fullScreen;
-	this->fullScreen = fullScreen;
-	this->aaLevel = aaLevel;
+	this->fullScreen = modeInfo->fullScreen;
+	this->aaLevel = modeInfo->aaLevel;
+    this->vSync = modeInfo->vSync;
 	
 	NSOpenGLPixelFormatAttribute attrs[32];
 	
@@ -271,14 +250,14 @@ void CocoaCore::_setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, i
 		CGLDisable(ctx, kCGLCESurfaceBackingSize);		
 	}
     
-	renderer->Resize(xRes, yRes);
+        // RENDERER_TODO
+	//renderer->Resize(xRes, yRes);
 
 	if(aaLevel > 0) {
 		glEnable( GL_MULTISAMPLE_ARB );
 	} else {
 		glDisable( GL_MULTISAMPLE_ARB );			
 	}
-	
 }
 
 void CocoaCore::openFileWithApplication(String file, String application) {
@@ -327,7 +306,8 @@ String CocoaCore::executeExternalCommand(String command,  String args, String in
 void CocoaCore::resizeTo(int xRes, int yRes) {
 	this->xRes = xRes;
 	this->yRes = yRes;
-	renderer->Resize(xRes, yRes);	
+    // RENDERER_TODO
+//	renderer->Resize(xRes, yRes);
 	dispatchEvent(new Event(), EVENT_CORE_RESIZE);	
 }
 
@@ -648,31 +628,18 @@ vector<String> CocoaCore::openFilePicker(vector<CoreFileExtension> extensions, b
 }
 
 void CocoaCore::Render() {
-	lockMutex(CoreServices::getRenderMutex());
-	
-	if(!paused) {	
-		renderer->BeginRender();
-	}
-
-	services->Render();
+    services->Render(Polycode::Rectangle(0, 0, getBackingXRes(), getBackingYRes()));
+    renderer->flushContext();
+}
 
-	if(!paused) {		
-		renderer->EndRender();
-		[context flushBuffer];
-	}
-	
-	unlockMutex(CoreServices::getRenderMutex());
+void CocoaCore::flushRenderContext() {
+    [context flushBuffer];
 }
 
 bool CocoaCore::systemUpdate() {
 	if(!running)
 		return false;
 	doSleep();
-	
-	if(modeChangeInfo.needResolutionChange) {
-		_setVideoMode(modeChangeInfo.xRes, modeChangeInfo.yRes, modeChangeInfo.fullScreen, modeChangeInfo.vSync, modeChangeInfo.aaLevel, modeChangeInfo.anisotropyLevel);
-		modeChangeInfo.needResolutionChange = false;
-	}
 							
 	updateCore();
 	checkEvents();

Core/Contents/Source/PolyCore.cpp

@@ -22,6 +22,7 @@
 
 #include "PolyCore.h"
 #include "PolyCoreInput.h"
+#include "PolyRenderer.h"
 #include "PolyCoreServices.h"
 
 #ifdef _WINDOWS
@@ -56,6 +57,9 @@ namespace Polycode {
 		int _hz;
 		getScreenInfo(&defaultScreenWidth, &defaultScreenHeight, &_hz);
 	
+        
+        this->aaLevel = aaLevel;
+        this->anisotropyLevel = anisotropyLevel;
 		services = CoreServices::getInstance();
 		input = new CoreInput();
 		services->setCore(this);
@@ -68,6 +72,7 @@ namespace Polycode {
 		elapsed = 0;
 		xRes = _xRes;
 		yRes = _yRes;
+        this->vSync = vSync;
 		paused = false;
 		pauseOnLoseFocus = false;
 		if (fullScreen && !xRes && !yRes) {
@@ -83,8 +88,25 @@ namespace Polycode {
 		
 		setFramerate(frameRate);
 		threadedEventMutex = NULL;
+        
 	}
     
+    void Core::setVideoMode(int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, bool retinaSupport) {
+        
+        VideoModeChangeInfo *modeChangeInfo =  new VideoModeChangeInfo();
+        
+        modeChangeInfo->retinaSupport = retinaSupport;
+        modeChangeInfo->xRes = xRes;
+        modeChangeInfo->yRes = yRes;
+        modeChangeInfo->fullScreen = fullScreen;
+        modeChangeInfo->vSync = vSync;
+        modeChangeInfo->aaLevel = aaLevel;
+        modeChangeInfo->anisotropyLevel = anisotropyLevel;
+        
+        renderer->getRenderThread()->enqueueJob(RenderThread::JOB_REQUEST_CONTEXT_CHANGE, modeChangeInfo);
+    }
+    
+    
     int Core::getScreenWidth() {
         int width, height, hz;
         getScreenInfo(&width, &height, &hz);

Core/Contents/Source/PolyCoreServices.cpp

@@ -25,7 +25,6 @@
 #include "PolyCoreInput.h"
 #include "PolyInputEvent.h"
 #include "PolyLogger.h"
-#include "PolyModule.h"
 #include "PolyResourceManager.h"
 #include "PolyMaterialManager.h"
 #include "PolyRenderer.h"
@@ -103,20 +102,6 @@ Logger *CoreServices::getLogger() {
 	return logger;
 }
 
-void CoreServices::installModule(PolycodeModule *module)  {
-	modules.push_back(module);
-	if(module->requiresUpdate()) {
-		updateModules.push_back(module);
-	}
-	
-	switch(module->getType()) {
-		case PolycodeModule::TYPE_SHADER:
-			materialManager->addShaderModule((PolycodeShaderModule*) module);
-			renderer->addShaderModule((PolycodeShaderModule*) module);
-		break;
-	}
-}
-
 void CoreServices::setupBasicListeners() {
 	this->setCore(this->core);	
 }
@@ -145,10 +130,6 @@ CoreServices::~CoreServices() {
     delete config;
     delete renderer;
 
-    for(std::size_t i = 0; i < modules.size(); i++) {
-        delete modules[i];
-    }
-    
 	instanceMap.clear();
 	overrideInstance = NULL;
 }
@@ -177,14 +158,12 @@ Renderer *CoreServices::getRenderer() {
 	return renderer;
 }
 
-void CoreServices::Render() {
-	if(renderer->doClearBuffer)		
-		renderer->clearScreen();
+void CoreServices::Render(const Polycode::Rectangle &viewport) {
 
-	renderer->setPerspectiveDefaults();
+//	renderer->setPerspectiveDefaults();
 	sceneManager->renderVirtual();
-	sceneManager->Render();
-	renderer->clearLights();
+	sceneManager->Render(viewport);
+//	renderer->clearLights();
 }
 
 void CoreServices::fixedUpdate() {
@@ -192,10 +171,6 @@ void CoreServices::fixedUpdate() {
 }
 
 void CoreServices::Update(int elapsed) {
-	
-	for(int i=0; i < updateModules.size(); i++) {
-		updateModules[i]->Update(elapsed);
-	}
 	resourceManager->Update(elapsed);
 	timerManager->Update();	
 	tweenManager->Update(elapsed);	

Core/Contents/Source/PolyEntity.cpp

@@ -59,7 +59,7 @@ void Entity::initEntity() {
 	billboardMode = false;
 	billboardRoll = false;
 	billboardIgnoreScale = false;
-	depthOnly = false;
+	drawCall.options.depthOnly = false;
 	depthWrite = true;
 	ignoreParentMatrix = false;
 	blendingMode = Entity::defaultBlendingMode;
@@ -116,7 +116,6 @@ void Entity::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) co
 	clone->blendingMode = blendingMode;
 	clone->colorAffectsChildren = colorAffectsChildren;
 	clone->visibilityAffectsChildren = visibilityAffectsChildren;
-	clone->depthOnly = depthOnly;
 	clone->setUserData(getUserData());
 	clone->entityProps = entityProps;
 	clone->bBox = bBox;
@@ -128,6 +127,8 @@ void Entity::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) co
     clone->setAnchorPoint(anchorPoint);
     clone->layerID = layerID;
     
+    clone->drawCall.options = drawCall.options;
+    
 	clone->id = id;
 	if(tags == NULL) {
 		clone->tags = NULL;
@@ -455,7 +456,8 @@ Matrix4 Entity::getConcatenatedRollMatrix() const {
 
 Vector2 Entity::getScreenPosition(const Matrix4 &projectionMatrix, const Matrix4 &cameraMatrix, const Polycode::Rectangle &viewport) {
 	if(renderer){
-		return renderer->Project(cameraMatrix, projectionMatrix, viewport, getConcatenatedMatrix().getPosition());
+        // RENDERER_TODO
+		//return renderer->Project(cameraMatrix, projectionMatrix, viewport, getConcatenatedMatrix().getPosition());
 	} else {
 		return Vector2();
 	}
@@ -463,13 +465,22 @@ Vector2 Entity::getScreenPosition(const Matrix4 &projectionMatrix, const Matrix4
 
 Vector2 Entity::getScreenPositionForMainCamera() {
 	if(renderer) {
-		return getScreenPosition(renderer->getProjectionMatrix(), renderer->getCameraMatrix(), renderer->getViewport());
+        // RENDERER_TODO
+		//return getScreenPosition(renderer->getProjectionMatrix(), renderer->getCameraMatrix(), renderer->getViewport());
 	} else {
 		return Vector2();
 	}
 }
 
-void Entity::transformAndRender() {
+void Entity::setDepthOnly(bool val) {
+    drawCall.options.depthOnly = true;
+}
+
+bool Entity::getDepthOnly() {
+    
+}
+
+void Entity::transformAndRender(GPUDrawBuffer *buffer) {
 	if(!renderer || !enabled)
 		return;
 
@@ -477,10 +488,9 @@ void Entity::transformAndRender() {
 		rebuildTransformMatrix();
     }
     
-	if(depthOnly) {
-		renderer->drawToColorBuffer(false);
-	}
+    
 	
+    /*
 	bool isScissorEnabled;
 	Polycode::Rectangle oldScissorBox;
 	
@@ -498,14 +508,15 @@ void Entity::transformAndRender() {
 
 		renderer->setScissorBox(finalScissorBox);
 	}
+     */
 		
-	renderer->pushMatrix();
-	if(ignoreParentMatrix && parentEntity) {
-		renderer->multModelviewMatrix(parentEntity->getConcatenatedMatrix().Inverse());
-	}
+	if(ignoreParentMatrix) {
+        drawCall.modelMatrix = transformMatrix;
+    } else {
+        drawCall.modelMatrix = getConcatenatedMatrix();
+    }
 
-    renderer->multModelviewMatrix(transformMatrix);
-	
+    /*
 	if(billboardMode) {
 		if(billboardIgnoreScale) {
 			renderer->billboardMatrix();
@@ -516,49 +527,21 @@ void Entity::transformAndRender() {
 			renderer->multModelviewMatrix(getConcatenatedRollMatrix());
 		}
 	}
-	
-	if(!depthWrite)
-		renderer->enableDepthWrite(false);
-	else
-		renderer->enableDepthWrite(true);
-	
-	if(!depthTest) 
-		renderer->enableDepthTest(false);
-	else
-		renderer->enableDepthTest(true);
-	
-    renderer->pushVertexColor();
-	renderer->multiplyVertexColor(color);
-	
-	renderer->setBlendingMode(blendingMode);
-	   
+*/
+    
+    
 	if(visible && rendererVis) {
-		renderer->pushMatrix();		
-		renderer->translate3D(-anchorPoint.x * bBox.x * 0.5, -anchorPoint.y * bBox.y * 0.5 * yAdjust, -anchorPoint.z * bBox.z * 0.5);
-		Render();
-		renderer->popMatrix();
+		Render(buffer);
 	}
     
-    if(!colorAffectsChildren) {
-        renderer->pushVertexColor();
-        renderer->loadVertexColorIdentity();
-        if(visible || (!visible && !visibilityAffectsChildren)) {
-            renderChildren();
-        }
-        renderer->popVertexColor();
-    } else {
-        if(visible || (!visible && !visibilityAffectsChildren)) {
-            renderChildren();
-        }
+    if(visible || (!visible && !visibilityAffectsChildren)) {
+        renderChildren(buffer);
     }
-		
+/*
     renderer->popVertexColor();
     
 	renderer->popMatrix();
 	
-	if(!depthWrite)
-		renderer->enableDepthWrite(true);
-	
 	
 	if(depthOnly) {
 		renderer->drawToColorBuffer(true);
@@ -568,6 +551,7 @@ void Entity::transformAndRender() {
 		renderer->enableScissor(isScissorEnabled);
 		renderer->setScissorBox(oldScissorBox);
 	}
+*/
 }
 
 void Entity::setRenderer(Renderer *renderer) {
@@ -578,9 +562,9 @@ void Entity::setRenderer(Renderer *renderer) {
 }
 
 
-void Entity::renderChildren() {
+void Entity::renderChildren(GPUDrawBuffer *buffer) {
 	for(int i=0;i<children.size();i++) {
-		children[i]->transformAndRender();
+		children[i]->transformAndRender(buffer);
 	}
 }
 

Core/Contents/Source/PolyGLCubemap.cpp

@@ -1,94 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolyGLCubemap.h"
-#include "PolyTexture.h"
-
-using namespace Polycode;
-
-OpenGLCubemap::OpenGLCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) : Cubemap(t0,t1,t2,t3,t4,t5) {
-	
-	glCubemapLoaded = false;
-
-	recreateFromTextures();
-}
-
-void OpenGLCubemap::recreateFromTextures() {
-
-	if(glCubemapLoaded) {
-		glDeleteTextures(1, &textureID);
-	}
-
-	glGenTextures(1, &textureID);
-	glBindTexture(GL_TEXTURE_CUBE_MAP, textureID);	
-	
-	
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);	
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	
-	Texture *tex;
-	
-	tex = getTexture(Cubemap::CUBEMAP_XPOS);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-    }
-    
-	tex = getTexture(Cubemap::CUBEMAP_XNEG);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-    }
-    
-	tex = getTexture(Cubemap::CUBEMAP_YPOS);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-    }
-    
-	tex = getTexture(Cubemap::CUBEMAP_YNEG);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-    }
-    
-	tex = getTexture(Cubemap::CUBEMAP_ZPOS);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-    }
-    
-	tex = getTexture(Cubemap::CUBEMAP_ZNEG);
-    if(tex) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGBA, tex->getWidth(), tex->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex->getTextureData());
-	}
-		
-	glCubemapLoaded = true;
-}
-
-OpenGLCubemap::~OpenGLCubemap() {
-	if(glCubemapLoaded) {
-		glDeleteTextures(1, &textureID);
-	}
-}
-
-GLuint OpenGLCubemap::getTextureID() {
-	return textureID;
-}

Core/Contents/Source/PolyGLRenderer.cpp

@@ -1,1050 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolyGLRenderer.h"
-#include "PolyString.h"
-#include "PolyLogger.h"
-#include "PolyTexture.h"
-#include "PolyVector2.h"
-#include "PolyGLTexture.h"
-#include "PolyCubemap.h"
-#include "PolyGLCubemap.h"
-#include "PolyGLVertexBuffer.h"
-#include "PolyFixedShader.h"
-#include "PolyMaterial.h"
-#include "PolyMesh.h"
-#include "PolyModule.h"
-
-#if defined(_WINDOWS) && !defined(_MINGW)
-
-
-PFNGLACTIVETEXTUREPROC   glActiveTexture;
-PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f;
-PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f;
-
-
-// ARB_vertex_buffer_object
-PFNGLBINDBUFFERARBPROC glBindBufferARB;
-PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB;
-PFNGLGENBUFFERSARBPROC glGenBuffersARB;
-PFNGLISBUFFERARBPROC glIsBufferARB;
-PFNGLBUFFERDATAARBPROC glBufferDataARB;
-PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB;
-PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB;
-PFNGLMAPBUFFERARBPROC glMapBufferARB;
-PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB;
-PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB;
-PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB;
-
-PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
-PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;
-PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;
-PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
-
-PFNGLGETPROGRAMIVPROC glGetProgramiv;
-PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform;
-
-// GL_EXT_framebuffer_object
-PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT;
-PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT;
-PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT;
-PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT;
-PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT;
-PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT;
-PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT;
-PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
-PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
-PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
-PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
-PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT;
-PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
-PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT;
-PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
-PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
-PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
-
-#endif
-using namespace Polycode;
-
-inline void polycodeGLGetNumberv( GLenum pname, GLdouble *params ) {
-	glGetDoublev(pname, params);
-}
-inline void polycodeGLGetNumberv( GLenum pname, GLfloat *params ) {
-	glGetFloatv(pname, params);
-}
-
-OpenGLRenderer::OpenGLRenderer() : Renderer() {
-
-	verticesToDraw = 0;
-
-}
-
-bool OpenGLRenderer::Init() {
-	if(!Renderer::Init())
-		return false;
-
-	glDisable(GL_SCISSOR_TEST);
-
-	return true;
-}
-
-void OpenGLRenderer::initOSSpecific(){
-		
-#ifdef _WINDOWS
-	glActiveTexture   = (PFNGLACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture");
-	glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)wglGetProcAddress("glMultiTexCoord2f");
-	glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)wglGetProcAddress("glMultiTexCoord3f");
-
-   // ARB_vertex_buffer_object
-        glBindBufferARB = (PFNGLBINDBUFFERARBPROC)wglGetProcAddress("glBindBufferARB");
-        glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)wglGetProcAddress("glDeleteBuffersARB");
-        glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)wglGetProcAddress("glGenBuffersARB");
-        glIsBufferARB = (PFNGLISBUFFERARBPROC)wglGetProcAddress("glIsBufferARB");
-        glBufferDataARB = (PFNGLBUFFERDATAARBPROC)wglGetProcAddress("glBufferDataARB");
-        glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)wglGetProcAddress("glBufferSubDataARB");
-        glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)wglGetProcAddress("glGetBufferSubDataARB");
-        glMapBufferARB = (PFNGLMAPBUFFERARBPROC)wglGetProcAddress("glMapBufferARB");
-        glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)wglGetProcAddress("glUnmapBufferARB");
-        glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)wglGetProcAddress("glGetBufferParameterivARB");
-        glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)wglGetProcAddress("glGetBufferPointervARB");
-
-		glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer");
-		glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)wglGetProcAddress("glEnableVertexAttribArrayARB");
-		glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)wglGetProcAddress("glDisableVertexAttribArrayARB");
-		glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)wglGetProcAddress("glBindAttribLocation");
-
-		
-		glGetProgramiv = (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv");
-		glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)wglGetProcAddress("glGetActiveUniform");
-
-        glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)wglGetProcAddress("glIsRenderbufferEXT");
-        glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)wglGetProcAddress("glBindRenderbufferEXT");
-        glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)wglGetProcAddress("glDeleteRenderbuffersEXT");
-        glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)wglGetProcAddress("glGenRenderbuffersEXT");
-        glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)wglGetProcAddress("glRenderbufferStorageEXT");
-        glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)wglGetProcAddress("glGetRenderbufferParameterivEXT");
-        glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)wglGetProcAddress("glIsFramebufferEXT");
-        glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)wglGetProcAddress("glBindFramebufferEXT");
-        glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)wglGetProcAddress("glDeleteFramebuffersEXT");
-        glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)wglGetProcAddress("glGenFramebuffersEXT");
-        glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)wglGetProcAddress("glCheckFramebufferStatusEXT");
-        glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)wglGetProcAddress("glFramebufferTexture1DEXT");
-        glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wglGetProcAddress("glFramebufferTexture2DEXT");
-        glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)wglGetProcAddress("glFramebufferTexture3DEXT");
-        glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)wglGetProcAddress("glFramebufferRenderbufferEXT");
-        glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)wglGetProcAddress("glGetFramebufferAttachmentParameterivEXT");
-        glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)wglGetProcAddress("glGenerateMipmapEXT");
-
-#endif
-}
-
-void OpenGLRenderer::Resize(int xRes, int yRes) {
-	this->xRes = xRes;
-	this->yRes = yRes;
-	viewportWidth = xRes;
-	viewportHeight = xRes;
-	glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
-	glClearDepth(1.0f);
-
-	glLineWidth(1);
-	glDepthFunc( GL_LEQUAL );
-	
-	glEnable(GL_DEPTH_TEST);
-	
-	glLineWidth(1.0f);
-	glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
-	GLint numBuffers;
-	glGetIntegerv(GL_MAX_DRAW_BUFFERS, &numBuffers);
-
-}
-
-void OpenGLRenderer::setDepthFunction(int depthFunction) {
-	switch(depthFunction) {
-		case DEPTH_FUNCTION_LEQUAL:
-			glDepthFunc(GL_LEQUAL);
-		break;
-		case DEPTH_FUNCTION_GREATER:
-			glDepthFunc(GL_GREATER);			
-		break;
-	}
-}
-
-void OpenGLRenderer::enableAlphaTest(bool val) {
-	if(val) {
-		glAlphaFunc ( GL_GREATER, alphaTestValue) ;
-		glEnable ( GL_ALPHA_TEST ) ;		
-	} else {
-		glDisable( GL_ALPHA_TEST ) ;
-	}
-}
-
-void OpenGLRenderer::setPointSmooth(bool val) {
-	if(val)
-		glEnable( GL_POINT_SMOOTH );
-	else
-		glDisable( GL_POINT_SMOOTH );
-
-}
-
-void OpenGLRenderer::setLineSmooth(bool val) {
-	if(val)
-		glEnable(GL_LINE_SMOOTH);
-	else
-		glDisable(GL_LINE_SMOOTH);
-}
-
-void OpenGLRenderer::setProjectionFromFrustum(Number left, Number right, Number bottom, Number top, Number front, Number back) {
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glFrustum(left, right, bottom, top, front, back);
-	glMatrixMode(GL_MODELVIEW);
-	polycodeGLGetNumberv(GL_PROJECTION_MATRIX, sceneProjectionMatrix);
-
-}
-
-void OpenGLRenderer::setProjectionFromFoV(Number fov, Number _near, Number _far) {
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	Number fW, fH;
-	fH = tan( fov / 360.0 * PI ) * _near;
-	fW = fH * ((GLfloat)viewportWidth/(GLfloat)viewportHeight);
-	glFrustum(-fW + (viewportShift.x*fW*2.0), fW + (viewportShift.x*fW*2.0), -fH + (viewportShift.y*fH*2.0), fH + (viewportShift.y*fH*2.0), _near, _far);
-	glMatrixMode(GL_MODELVIEW);
-	polycodeGLGetNumberv(GL_PROJECTION_MATRIX, sceneProjectionMatrix);
-}
-
-void OpenGLRenderer::resetViewport() {
-	glViewport(0, 0, viewportWidth*backingResolutionScaleX, viewportHeight*backingResolutionScaleY);
-	glScissor(0, 0,  viewportWidth*backingResolutionScaleX, viewportHeight*backingResolutionScaleY);
-}
-
-Vector3 OpenGLRenderer::Unproject(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport) {
-	Vector3 coords;
-	GLfloat wx, wy, wz;
-	GLdouble cx, cy, cz;
-
-	GLdouble mv[16];
-	Matrix4 camInverse = cameraMatrix.Inverse();
-	Matrix4 cmv;
-	cmv.identity();
-	cmv = cmv * camInverse;
-    
-	for(int i=0; i < 16; i++) {
-		mv[i] = cmv.ml[i];
-	}
-    
-	GLint vp[4] = {viewport.x, viewport.y, viewport.w, viewport.h};
-    
-	GLdouble _sceneProjectionMatrix[16];
-	for(int i=0; i < 16; i++) {
-		_sceneProjectionMatrix[i] = projectionMatrix.ml[i];
-	}	
-	
-	wx = ( Number ) x;
-	wy = ( Number ) vp[3] - ( Number ) y;
-	glReadPixels( x * backingResolutionScaleX, wy * backingResolutionScaleY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &wz );
-	
-	gluUnProject( wx, wy, wz, mv, _sceneProjectionMatrix, vp, &cx, &cy, &cz );
-	
-	coords = Vector3( cx, cy, cz );
-	
-	return coords;	
-}
-
-Vector2 OpenGLRenderer::Project(const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport, const Vector3 &coordiante) const {
-    
-	GLdouble mv[16];
-	Matrix4 camInverse = cameraMatrix.Inverse();	
-	Matrix4 cmv;
-	cmv.identity();
-	cmv = cmv * camInverse;
-    
-	for(int i=0; i < 16; i++) {
-		mv[i] = cmv.ml[i];
-	}
-    
-	GLint vp[4] = {viewport.x, viewport.y, viewport.w, viewport.h};
-
-	GLdouble _sceneProjectionMatrix[16];
-	for(int i=0; i < 16; i++) {
-		_sceneProjectionMatrix[i] = projectionMatrix.ml[i];
-	}	
-
-	GLdouble coords[3];
-	
-	gluProject(coordiante.x, coordiante.y, coordiante.z, mv, _sceneProjectionMatrix, vp, &coords[0], &coords[1], &coords[2]);
-	
-    return Vector2(coords[0] / backingResolutionScaleX, (viewport.h-coords[1]) / backingResolutionScaleY);
-}
-
-Polycode::Rectangle OpenGLRenderer::getViewport() {
-	GLint vp[4];
-	glGetIntegerv( GL_VIEWPORT, vp );
-	return Polycode::Rectangle(vp[0], vp[1], vp[2], vp[3]); 
-}
-
-Vector3 OpenGLRenderer::projectRayFrom2DCoordinate(Number x, Number y, const Matrix4 &cameraMatrix, const Matrix4 &projectionMatrix, const Polycode::Rectangle &viewport) {
-	GLdouble nearPlane[3],farPlane[3];
-
-	GLdouble mv[16];
-	Matrix4 camInverse = cameraMatrix.Inverse();	
-	Matrix4 cmv;
-	cmv.identity();
-	cmv = cmv * camInverse;
-
-	for(int i=0; i < 16; i++) {
-		mv[i] = cmv.ml[i];
-	}
-
-	GLint vp[4] = {viewport.x, viewport.y, viewport.w, viewport.h};
-
-	GLdouble _sceneProjectionMatrix[16];
-	for(int i=0; i < 16; i++) {
-		_sceneProjectionMatrix[i] = projectionMatrix.ml[i];
-	}
-
-	gluUnProject(x, (yRes*backingResolutionScaleY) - y, 0.0, mv, _sceneProjectionMatrix, vp, &nearPlane[0], &nearPlane[1], &nearPlane[2]);
-	gluUnProject(x, (yRes*backingResolutionScaleY) - y, 1.0, mv, _sceneProjectionMatrix, vp, &farPlane[0], &farPlane[1], &farPlane[2]);
-
-	Vector3 nearVec(nearPlane[0], nearPlane[1], nearPlane[2]);
-	Vector3 farVec(farPlane[0], farPlane[1], farPlane[2]);
-
-	Vector3 dirVec = (farVec) - (nearVec);	
-	dirVec.Normalize();
-
-	return dirVec;
-}
-
-void OpenGLRenderer::enableDepthWrite(bool val) {
-	if(val)
-		glDepthMask(GL_TRUE);
-	else
-		glDepthMask(GL_FALSE);	
-}
-
-void OpenGLRenderer::enableDepthTest(bool val) {
-	if(val)
-		glEnable(GL_DEPTH_TEST);
-	else
-		glDisable(GL_DEPTH_TEST);	
-}
-
-inline void loadMatrixNumber(const GLfloat* m) {
-	glLoadMatrixf(m);
-}
-
-inline void loadMatrixNumber(const GLdouble* m) {
-	glLoadMatrixd(m);
-}
-
-inline void multMatrixNumber(const GLfloat* m) {
-	glMultMatrixf(m);
-}
-
-inline void multMatrixNumber(const GLdouble* m) {
-	glMultMatrixd(m);
-}
-
-void OpenGLRenderer::setModelviewMatrix(Matrix4 m) {
-	loadMatrixNumber(m.ml);
-}
-
-void OpenGLRenderer::multModelviewMatrix(Matrix4 m) {
-//	glMatrixMode(GL_MODELVIEW);
-	multMatrixNumber(m.ml);
-}
-
-void OpenGLRenderer::enableLighting(bool enable) {
-	lightingEnabled = enable;
-}
-
-void OpenGLRenderer::setLineSize(Number lineSize) {
-	glLineWidth(lineSize);
-}
-
-void OpenGLRenderer::setPointSize(Number pointSize) {
-	glPointSize(pointSize);
-}
-
-void OpenGLRenderer::createVertexBufferForMesh(Mesh *mesh) {
-	OpenGLVertexBuffer *buffer = new OpenGLVertexBuffer(mesh);
-	mesh->setVertexBuffer(buffer);
-}
-
-void OpenGLRenderer::drawVertexBuffer(VertexBuffer *buffer, bool enableColorBuffer) {
-	OpenGLVertexBuffer *glVertexBuffer = (OpenGLVertexBuffer*)buffer;
-
-	glEnableClientState(GL_VERTEX_ARRAY);		
-    glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getVertexBufferID());
-	glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );
-
-	if(enableColorBuffer && glVertexBuffer->getColorBufferID() != -1)  {
-		glEnableClientState(GL_COLOR_ARRAY);
-		glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getColorBufferID());
-		glColorPointer( 4, GL_FLOAT, 0, (char *) NULL );	
-	}
-    
-    if(glVertexBuffer->getNormalBufferID() != -1) {
-        glEnableClientState(GL_NORMAL_ARRAY);
-        glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getNormalBufferID());
-        glNormalPointer(GL_FLOAT, 0, (char *) NULL );
-    }
-    
-    if(glVertexBuffer->getTextCoordBufferID() != -1) {
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-        glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getTextCoordBufferID());
-        glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );
-    }
-    
-    if(glVertexBuffer->getTangentBufferID() != -1) {
-        glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getTangentBufferID());
-        glEnableVertexAttribArrayARB(6);	
-        glVertexAttribPointer(6, 3, GL_FLOAT, 0, 0,  (char *)NULL);
-	}
-    
-    if(glVertexBuffer->getBoneWeightBufferID() != -1) {
-        
-        glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getBoneWeightBufferID());
-        glEnableVertexAttribArrayARB(7);
-        glVertexAttribPointer(7, 4, GL_FLOAT, 0, 0,  (char *)NULL);
-    }
-    
-    if(glVertexBuffer->getBoneIndexBufferID() != -1) {
-        
-        glBindBufferARB( GL_ARRAY_BUFFER_ARB, glVertexBuffer->getBoneIndexBufferID());
-        glEnableVertexAttribArrayARB(8);
-        glVertexAttribPointer(8, 4, GL_FLOAT, 0, 0,  (char *)NULL);
-    }
-    
-	GLenum mode = GL_TRIANGLES;
-	
-	switch(buffer->meshType) {
-		case Mesh::TRI_MESH:
-            mode = GL_TRIANGLES;
-			break;
-		case Mesh::TRIFAN_MESH:
-            mode = GL_TRIANGLE_FAN;
-			break;
-		case Mesh::QUAD_MESH:
-            mode = GL_QUADS;
-			break;
-		case Mesh::LINE_STRIP_MESH:
-			mode = GL_LINE_STRIP;
-			break;	
-		case Mesh::LINE_LOOP_MESH:
-			mode = GL_LINE_LOOP;
-			break;				
-		case Mesh::LINE_MESH:
-			mode = GL_LINES;
-			break;				
-		case Mesh::POINT_MESH:
-			mode = GL_POINTS;
-			break;
-	}	
-	
-    if(glVertexBuffer->getIndexBufferID() != -1) {
-        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, glVertexBuffer->getIndexBufferID());
-        glDrawElements(mode, glVertexBuffer->getIndexCount(), GL_UNSIGNED_INT, (void*)0);
-        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-    } else {
-        glDrawArrays( mode, 0, buffer->getVertexCount() );
-	}
-    
-    glDisableVertexAttribArrayARB(6);
-    glDisableVertexAttribArrayARB(7);
-    glDisableVertexAttribArrayARB(8);
-    
-	glDisableClientState( GL_VERTEX_ARRAY);
-	glDisableClientState( GL_TEXTURE_COORD_ARRAY );		
-	glDisableClientState( GL_NORMAL_ARRAY );
-	glDisableClientState( GL_COLOR_ARRAY );
-}
-
-void OpenGLRenderer::enableScissor(bool val) {
-	if(val) {
-		glEnable(GL_SCISSOR_TEST);
-	} else {
-		glDisable(GL_SCISSOR_TEST);	
-	}
-	Renderer::enableScissor(val);
-}
-
-void OpenGLRenderer::setScissorBox(Polycode::Rectangle box) {
-	glScissor(box.x*backingResolutionScaleX, (((yRes*backingResolutionScaleY)-(box.y*backingResolutionScaleY))-(box.h*backingResolutionScaleY)), box.w *backingResolutionScaleX, box.h * backingResolutionScaleY);
-	Renderer::setScissorBox(box);
-}
-
-void OpenGLRenderer::enableFog(bool enable) {
-	if(enable)
-		glEnable(GL_FOG);
-	else {
-		glDisable(GL_FOG);
-		glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
-	}
-}
-
-void OpenGLRenderer::setBlendingMode(int blendingMode) {
-    
-    if(blendingMode == BLEND_MODE_NONE) {
-        glDisable(GL_BLEND);
-    } else {
-        glEnable(GL_BLEND);
-    }
-    
-	switch(blendingMode) {
-		case BLEND_MODE_NORMAL:
-			if(blendNormalAsPremultiplied) {
-				glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);			
-			} else{
-				glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-			}
-		break;
-		case BLEND_MODE_LIGHTEN:
-				glBlendFunc (GL_SRC_ALPHA, GL_ONE);
-		break;
-		case BLEND_MODE_COLOR:
-				glBlendFunc (GL_DST_COLOR, GL_SRC_COLOR);
-		break;
-		case BLEND_MODE_PREMULTIPLIED:
-			glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-		break;
-		case BLEND_MODE_MULTIPLY:
-			glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);
-		break;
-		default:
-			glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		break;
-	}
-}
-
-Matrix4 OpenGLRenderer::getProjectionMatrix() {
-	Number m[16];
-	polycodeGLGetNumberv( GL_PROJECTION_MATRIX, m);
-	return Matrix4(m);
-}
-
-Matrix4 OpenGLRenderer::getModelviewMatrix() {
-	Number m[16];
-	polycodeGLGetNumberv( GL_MODELVIEW_MATRIX, m);
-	return Matrix4(m);
-}
-
-Image *OpenGLRenderer::renderBufferToImage(Texture *texture) {
-    
-	OpenGLTexture *glTexture = (OpenGLTexture*)texture;
-	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glTexture->getFrameBufferID());
-    glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
-    
-	char *imageBuffer = (char*)malloc(texture->getWidth() * backingResolutionScaleX * texture->getHeight() * backingResolutionScaleY * 4);
-	glReadPixels(0, 0, texture->getWidth() * backingResolutionScaleX, texture->getHeight() * backingResolutionScaleY, GL_RGBA, GL_UNSIGNED_BYTE, imageBuffer);
-	Image *retImage = new Image(imageBuffer, texture->getWidth() * backingResolutionScaleX, texture->getHeight() * backingResolutionScaleY, Image::IMAGE_RGBA);
-	free(imageBuffer);
-    
-    unbindFramebuffers();
-	return retImage;
-}
-
-Image *OpenGLRenderer::renderScreenToImage() {
-    glReadBuffer(GL_FRONT);
-    
-	char *imageBuffer = (char*)malloc(xRes* backingResolutionScaleX * yRes * backingResolutionScaleY * 4);
-	glReadPixels(0, 0, xRes * backingResolutionScaleX, yRes * backingResolutionScaleY, GL_RGBA, GL_UNSIGNED_BYTE, imageBuffer);
-	Image *retImage = new Image(imageBuffer, xRes * backingResolutionScaleX, yRes * backingResolutionScaleY, Image::IMAGE_RGBA);
-	free(imageBuffer);
-	return retImage;
-}
-
-void OpenGLRenderer::setFogProperties(int fogMode, Color color, Number density, Number startDepth, Number endDepth) {
-	switch(fogMode) {
-		case FOG_LINEAR:
-			glFogi(GL_FOG_MODE, GL_LINEAR);
-		break;
-		case FOG_EXP:
-				glFogi(GL_FOG_MODE, GL_EXP);
-		break;
-		case FOG_EXP2:
-				glFogi(GL_FOG_MODE, GL_EXP2);
-		break;
-		default:
-				glFogi(GL_FOG_MODE, GL_LINEAR);
-		break;
-	}
-
-	GLfloat fogColor[4]= {color.r, color.g, color.b, color.a};
-	glFogfv(GL_FOG_COLOR, fogColor);
-	glFogf(GL_FOG_DENSITY, density);
-	glHint(GL_FOG_HINT, GL_DONT_CARE);
-	glFogf(GL_FOG_START, startDepth);
-	glFogf(GL_FOG_END, endDepth);
-}
-
-void OpenGLRenderer::setProjectionOrtho(Number xSize, Number ySize, Number _near, Number _far, bool centered) {
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-		
-	if(centered) {
-		glOrtho(-xSize*0.5, xSize*0.5, -ySize*0.5, ySize*0.5, _near, _far);
-	} else {
-		glOrtho(0.0f, xSize, 0, ySize, _near, _far);
-	}
-	polycodeGLGetNumberv( GL_PROJECTION_MATRIX, sceneProjectionMatrixOrtho);
-
-	glMatrixMode(GL_MODELVIEW);	
-	glLoadIdentity();
-}
-
-void OpenGLRenderer::setProjectionMatrix(Matrix4 matrix) {
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    
-	loadMatrixNumber(matrix.ml);
-    
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-}
-
-void OpenGLRenderer::enableBackfaceCulling(bool val) {
-	if(val)
-		glEnable(GL_CULL_FACE);
-	else
-		glDisable(GL_CULL_FACE);
-}
-
-void OpenGLRenderer::setPerspectiveDefaults() {
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_CULL_FACE);
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-	
-	polycodeGLGetNumberv( GL_PROJECTION_MATRIX, sceneProjectionMatrix);
-	currentTexture = NULL;
-}
-
-void OpenGLRenderer::BeginRender() {
-    
-    Renderer::BeginRender();
-    
-	if(doClearBuffer) {
-		glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
-		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	}
-	glLoadIdentity();
-	currentTexture = NULL;
-}
-
-void OpenGLRenderer::translate3D(const Vector3 &position) {
-	glTranslatef(position.x, position.y, position.z);
-}
-
-void OpenGLRenderer::translate3D(Number x, Number y, Number z) {
-	glTranslatef(x, y, z);
-}
-
-void OpenGLRenderer::scale3D(const Vector3 &scale) {
-	glScalef(scale.x, scale.y, scale.z);
-}
-
-void OpenGLRenderer::bindFrameBufferTextureDepth(Texture *texture) {
-	if(!texture)
-		return;
-	OpenGLTexture *glTexture = (OpenGLTexture*)texture;
-	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, glTexture->getFrameBufferID());
-    Renderer::bindFrameBufferTextureDepth(texture);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	        
-}
-
-
-void OpenGLRenderer::bindFrameBufferTexture(Texture *texture) {
-	if(!texture)
-		return;
-	OpenGLTexture *glTexture = (OpenGLTexture*)texture;
-	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, glTexture->getFrameBufferID());
-    Renderer::bindFrameBufferTexture(texture);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-
-void OpenGLRenderer::unbindFramebuffers() {
-	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-	glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
-    Renderer::unbindFramebuffers();
-}
-
-void OpenGLRenderer::createRenderTextures(Texture **colorBuffer, Texture **depthBuffer, int width, int height, bool floatingPointBuffer) {
-			
-	GLuint depthTexture,colorTexture;
-	GLenum status;
-	GLuint frameBufferID;
-	
-	glGenFramebuffersEXT(1, &frameBufferID);   
-	
-	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBufferID);     	
-	glGenTextures(1,&colorTexture);
-	glBindTexture(GL_TEXTURE_2D,colorTexture);
-    if(textureFilteringMode == TEX_FILTERING_NEAREST) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    } else {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    }
-	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);	
-	
-	if(floatingPointBuffer) {
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, width* backingResolutionScaleX, height* backingResolutionScaleY, 0, GL_RGBA, GL_FLOAT, NULL);
-	} else {
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width * backingResolutionScaleX, height * backingResolutionScaleY, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-	}
-	
-	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, colorTexture, 0);
-
-	status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-	if(status == GL_FRAMEBUFFER_COMPLETE_EXT) {
-//		Logger::log("color fbo generation successful\n");
-	} else {
-		Logger::log("color fbo generation failed\n");	
-	}
-
-	if(colorBuffer) {
-		OpenGLTexture *colorBufferTexture = new OpenGLTexture(width, height);
-		colorBufferTexture->setGLInfo(colorTexture, frameBufferID);
-		*colorBuffer = ((Texture*)colorBufferTexture);
-	}
-	
-	if(depthBuffer) {
-		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBufferID);     
-		glGenTextures(1,&depthTexture);
-		glBindTexture(GL_TEXTURE_2D,depthTexture);
-        if(textureFilteringMode == TEX_FILTERING_NEAREST) {
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        } else {
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        }
-		glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-		glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-
-	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,GL_COMPARE_R_TO_TEXTURE);
-	//	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);	
-		glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);	
-	
-		if(floatingPointBuffer) {	
-			glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT16,width* backingResolutionScaleX,height * backingResolutionScaleY,0,GL_DEPTH_COMPONENT,GL_FLOAT,0);
-		} else {
-			glTexImage2D(GL_TEXTURE_2D,0,GL_DEPTH_COMPONENT,width* backingResolutionScaleX,height* backingResolutionScaleY,0,GL_DEPTH_COMPONENT,GL_UNSIGNED_BYTE,0);
-		}
-	
-		glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depthTexture, 0);
-
-		status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
-
-		if(status == GL_FRAMEBUFFER_COMPLETE_EXT) {
-//			Logger::log("depth fbo generation successful\n");
-		} else {
-			Logger::log("depth fbo generation failed\n");	
-		}
-		
-		OpenGLTexture *depthBufferTexture = new OpenGLTexture(width, height);
-		depthBufferTexture->setGLInfo(depthTexture, frameBufferID);	
-		*depthBuffer = ((Texture*)depthBufferTexture);		
-	}
-	
-    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-}
-
-Texture *OpenGLRenderer::createFramebufferTexture(unsigned int width, unsigned int height) {
-	OpenGLTexture *newTexture = new OpenGLTexture(width, height);	
-	return newTexture;
-}
-
-Cubemap *OpenGLRenderer::createCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) {
-	OpenGLCubemap *newCubemap = new OpenGLCubemap(t0,t1,t2,t3,t4,t5);
-	return newCubemap;
-}
-
-Texture *OpenGLRenderer::createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type) {
-	OpenGLTexture *newTexture = new OpenGLTexture(width, height, textureData, clamp, createMipmaps, textureFilteringMode, type);
-	return newTexture;
-}
-
-void OpenGLRenderer::destroyTexture(Texture *texture) {
-	OpenGLTexture *glTex = (OpenGLTexture*)texture;
-	delete glTex;
-}
-
-void OpenGLRenderer::clearScreen(bool useClearColor, bool useClearDepth) {
-	if (useClearColor) {
-		glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
-	}
-	GLbitfield mask = 0;
-	if (useClearColor) {
-		mask |= GL_COLOR_BUFFER_BIT;
-	}
-	if (useClearDepth) {
-		mask |= GL_DEPTH_BUFFER_BIT;
-	}
-	if (mask) {
-		glClear(mask);
-	}
-}
-
-void OpenGLRenderer::drawToColorBuffer(bool val) {
-	if(val) {
-		glDrawBuffer(GL_BACK);
-	} else {
-		glDrawBuffer(GL_NONE);		
-	}
-}
-
-void OpenGLRenderer::cullFrontFaces(bool val) {
-	if(val) {
-		glCullFace(GL_FRONT);
-		cullingFrontFaces = true;
-	} else {
-		glCullFace(GL_BACK);	
-		cullingFrontFaces = false;	
-	}
-}
-
-void OpenGLRenderer::clearBuffer(bool colorBuffer, bool depthBuffer) {
-	GLbitfield clearMask = 0;
-	
-	if(colorBuffer) {
-		clearMask = clearMask | GL_COLOR_BUFFER_BIT;
-	} 
-	
-	if(depthBuffer) {
-		clearMask = clearMask | GL_DEPTH_BUFFER_BIT;
-	} 
-	
-	glClear(clearMask);	
-}
-
-void OpenGLRenderer::clearShader() {
-
-	glDisable(GL_COLOR_MATERIAL);
-	glDisable(GL_LIGHTING);
-	glDisable(GL_FOG);
-	
-	for(int i=0; i < 4; i++)  {
-		glActiveTexture(GL_TEXTURE0+i);		
-		glDisable(GL_TEXTURE_2D);
-	}
-		
-	if(currentShaderModule) {
-		currentShaderModule->clearShader();
-		currentShaderModule = NULL;
-	}
-	currentMaterial = NULL;
-}
-
-void OpenGLRenderer::setTexture(Texture *texture) {
-
-	if(texture == NULL) {
-		glActiveTexture(GL_TEXTURE0);		
-		glDisable(GL_TEXTURE_2D);
-		return;
-	}
-	
-    glActiveTexture(GL_TEXTURE0);
-    glEnable (GL_TEXTURE_2D);
-            
-    if(currentTexture != texture) {			
-        OpenGLTexture *glTexture = (OpenGLTexture*)texture;
-        glBindTexture (GL_TEXTURE_2D, glTexture->getTextureID());
-    }
-	
-	currentTexture = texture;
-}
-
-void OpenGLRenderer::pushMatrix() {
-	glMatrixMode(GL_MODELVIEW);
-	glPushMatrix();
-}
-
-void OpenGLRenderer::popMatrix() {
-	glMatrixMode(GL_MODELVIEW);
-	glPopMatrix();
-}
-
-void OpenGLRenderer::pushRenderDataArray(RenderDataArray *array) {
-	
-	switch(array->type) {
-		case RenderDataArray::VERTEX_DATA_ARRAY:
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);
-			glVertexPointer(3, GL_FLOAT, 0, array->getArrayData());
-			verticesToDraw = array->getDataSize() / 3;
-		break;
-		case RenderDataArray::COLOR_DATA_ARRAY:
-            if(array->getDataSize() != verticesToDraw * 4) {
-                return;
-            }
-			glColorPointer(4, GL_FLOAT, 0, array->getArrayData());
-			glEnableClientState(GL_COLOR_ARRAY);
-		break;
-		case RenderDataArray::TEXCOORD_DATA_ARRAY:
-            if(array->getDataSize() != verticesToDraw * 2) {
-                return;
-            }
-			glEnableClientState(GL_TEXTURE_COORD_ARRAY);						
-			glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);			
-			glTexCoordPointer(2, GL_FLOAT, 0, array->getArrayData());
-		break;
-		case RenderDataArray::NORMAL_DATA_ARRAY:
-            if(array->getDataSize() != verticesToDraw * 3) {
-                return;
-            }
-			glEnableClientState(GL_NORMAL_ARRAY);	
-			glBindBufferARB( GL_ARRAY_BUFFER_ARB, 0);			
-			glNormalPointer(GL_FLOAT, 0, array->getArrayData());
-		break;
-		case RenderDataArray::TANGENT_DATA_ARRAY:
-            if(array->getDataSize() != verticesToDraw * 3) {
-                return;
-            }
-			glEnableVertexAttribArrayARB(6);		
-			glVertexAttribPointer(6, 3, GL_FLOAT, 0, 0, array->getArrayData());
-		break;
-		
-	}
-}
-
-void OpenGLRenderer::setWireframePolygonMode(bool val) {
-    if(val) {
-        glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
-    } else {
-        glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
-    }
-}
-
-void OpenGLRenderer::drawArrays(int drawType, IndexDataArray *indexArray) {
-	
-	GLenum mode = GL_TRIANGLES;
-	
-	switch(drawType) {
-		case Mesh::TRI_MESH:
-            mode = GL_TRIANGLES;
-			break;
-		case Mesh::TRIFAN_MESH:
-            mode = GL_TRIANGLE_FAN;
-			break;
-		case Mesh::QUAD_MESH:
-            mode = GL_QUADS;
-			break;
-		case Mesh::LINE_STRIP_MESH:
-			mode = GL_LINE_STRIP;
-			break;
-		case Mesh::LINE_LOOP_MESH:
-			mode = GL_LINE_LOOP;
-			break;								
-		case Mesh::LINE_MESH:
-			mode = GL_LINES;
-			break;				
-		case Mesh::POINT_MESH:
-			mode = GL_POINTS;
-		break;
-	}
-	
-    if(indexArray) {
-        if(indexArray->getDataSize() > 0) {
-            glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0);            
-            glDrawElements(mode, indexArray->getDataSize(), GL_UNSIGNED_INT, indexArray->getArrayData());
-        }
-    } else {
-        glDrawArrays( mode, 0, verticesToDraw);
-	}
-    
-	verticesToDraw = 0;
-		
-	glDisableClientState( GL_VERTEX_ARRAY);	
-	glDisableClientState( GL_TEXTURE_COORD_ARRAY );		
-	glDisableClientState( GL_NORMAL_ARRAY );
-	glDisableClientState( GL_COLOR_ARRAY );
-    glDisableVertexAttribArrayARB(6);
-}
-
-void OpenGLRenderer::drawScreenQuad(Number qx, Number qy) {
-	glMatrixMode(GL_PROJECTION);
-	glPushMatrix();
-	glMatrixMode(GL_MODELVIEW);
-	glPushMatrix();
-	setProjectionOrtho();
-	
-	Number xscale = qx/((Number)viewportWidth) * 2.0f;
-	Number yscale = qy/((Number)viewportHeight) * 2.0f;	
-
-	glBegin(GL_QUADS);
-		glColor4f(1.0f,1.0f,1.0f,1.0f);
-
-		glTexCoord2f(0.0f, 1.0f);
-		glVertex2f(-1, -1+(1.0f*yscale));
-
-		glTexCoord2f(0.0f, 0.0f);
-		glVertex2f(-1.0f, -1.0f);
-
-		glTexCoord2f(1.0f, 0.0f);
-		glVertex2f(-1+(1.0f*xscale), -1.0f);
-
-		glTexCoord2f(1.0f, 1.0f);
-		glVertex2f(-1+(1.0f*xscale), -1+(1.0f*yscale));
-	glEnd();
-
-	glMatrixMode(GL_PROJECTION);
-	glPopMatrix();
-	glMatrixMode(GL_MODELVIEW);
-	glPopMatrix();
-	setPerspectiveDefaults();
-}
-
-
-void OpenGLRenderer::translate2D(Number x, Number y) {
-	glTranslatef(x, y, 0.0f);
-}
-
-void OpenGLRenderer::scale2D(const Vector2 &scale) {
-	glScalef(scale.x, scale.y, 1.0f);
-}
-
-void OpenGLRenderer::loadIdentity() {
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-}
-
-void OpenGLRenderer::rotate2D(Number angle) {
-	glRotatef(angle, 0.0f, 0.0f, 1.0f);
-}
-
-void OpenGLRenderer::setVertexColor(Number r, Number g, Number b, Number a) {
-	glColor4f(r,g,b,a);
-}
-
-void OpenGLRenderer::EndRender() {
-    Renderer::EndRender();
-///	glFlush();
-//	glFinish();	
-}
-
-OpenGLRenderer::~OpenGLRenderer() {
-
-}

Core/Contents/Source/PolyGLSLProgram.cpp

@@ -1,116 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-
-#include "PolyGLSLProgram.h"
-#include "PolyVector3.h"
-#include "PolyVector2.h"
-#include "PolyColor.h"
-#include "PolyLogger.h"
-#include "PolyCoreServices.h"
-#include "PolyLogger.h"
-#include "PolyGLHeaders.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-
-// Some shader functions that aren't defined in glext/wglext
-extern PFNGLGETSHADERIVPROC glGetShaderiv;
-extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
-
-#endif
-
-#include "PolyGLHeaders.h"
-
-using std::vector;
-
-#ifdef _WINDOWS
-extern PFNGLUSEPROGRAMPROC glUseProgram;
-extern PFNGLUNIFORM1IPROC glUniform1i;
-extern PFNGLACTIVETEXTUREPROC glActiveTexture;
-extern PFNGLCREATESHADERPROC glCreateShader;
-extern PFNGLSHADERSOURCEPROC glShaderSource;
-extern PFNGLCOMPILESHADERPROC glCompileShader;
-extern PFNGLCREATEPROGRAMPROC glCreateProgram;
-extern PFNGLATTACHSHADERPROC glAttachShader;
-extern PFNGLLINKPROGRAMPROC glLinkProgram;
-extern PFNGLDETACHSHADERPROC glDetachShader;
-extern PFNGLDELETESHADERPROC glDeleteShader;
-extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
-#ifndef _MINGW
-extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
-#endif
-#endif
-
-using namespace Polycode;
-
-GLSLProgram::GLSLProgram(String fileName, int type) : ShaderProgram(type) {
-	program = -1;
-	this->fileName = fileName;
-	reloadProgram();
-}
-
-GLSLProgram::~GLSLProgram() {
-	glDeleteShader(program);
-}
-
-void GLSLProgram::reloadProgram() {
-	if(program != -1)
-		glDeleteShader(program);
-		
-	OSFILE *file = OSBasics::open(fileName, "rb");
-	if (!file) {
-		Logger::log("Error: shader file %s not found\n", fileName.c_str());
-		program = -1;
-		return;
-	}
-	OSBasics::seek(file, 0, SEEK_END);	
-	long progsize = OSBasics::tell(file);
-	OSBasics::seek(file, 0, SEEK_SET);
-	char *buffer = (char*)malloc(progsize+1);
-	memset(buffer, 0, progsize+1);
-	OSBasics::read(buffer, progsize, 1, file);
-	OSBasics::close(file);
-	
-	if(type == GLSLProgram::TYPE_VERT) {
-		program =  glCreateShader(GL_VERTEX_SHADER);
-	} else {
-		program =  glCreateShader(GL_FRAGMENT_SHADER);
-	}
-	
-	glShaderSource(program, 1, (const GLchar**)&buffer, 0);
-	glCompileShader(program);	
-	
-	GLint compiled = true;
-    glGetShaderiv(program, GL_COMPILE_STATUS, &compiled);
-    if(!compiled) {
-        GLint length;
-        GLchar* log;
-        glGetShaderiv(program, GL_INFO_LOG_LENGTH, &length);
-        log = (GLchar*)malloc(length);
-        glGetShaderInfoLog(program, length, &length, log);
-		printf("GLSL ERROR: %s\n", log);
-		CoreServices::getInstance()->getLogger()->logBroadcast("GLSL ERROR:" + String(log));
-        free(log);
-    }	
-	free(buffer);
-}

Core/Contents/Source/PolyGLSLShader.cpp

@@ -1,214 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-
-#include "PolyGLSLShader.h"
-
-#include "PolyLogger.h"
-#include "PolyShader.h"
-#include "PolyGLSLProgram.h"
-#include "PolyTexture.h"
-#include "PolyCubemap.h"
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-#include "PolyGLHeaders.h"
-
-using std::vector;
-
-#ifdef _WINDOWS
-extern PFNGLUSEPROGRAMPROC glUseProgram;
-extern PFNGLUNIFORM1IPROC glUniform1i;
-extern PFNGLACTIVETEXTUREPROC glActiveTexture;
-extern PFNGLGETPROGRAMIVPROC glGetProgramiv;
-extern PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform;
-extern PFNGLCREATESHADERPROC glCreateShader;
-extern PFNGLSHADERSOURCEPROC glShaderSource;
-extern PFNGLCOMPILESHADERPROC glCompileShader;
-extern PFNGLCREATEPROGRAMPROC glCreateProgram;
-extern PFNGLATTACHSHADERPROC glAttachShader;
-extern PFNGLLINKPROGRAMPROC glLinkProgram;
-extern PFNGLDETACHSHADERPROC glDetachShader;
-extern PFNGLDELETESHADERPROC glDeleteShader;
-extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
-extern PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
-#ifndef _MINGW
-extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
-#endif
-#endif
-
-using namespace Polycode;
-
-int GLSLShader::getPolycodeParamType(int glType) {
-	switch(glType) {
-		case GL_FLOAT:
-			return ProgramParam::PARAM_NUMBER;
-		break;
-		case GL_FLOAT_VEC2:
-			return ProgramParam::PARAM_VECTOR2;
-		break;
-		case GL_FLOAT_VEC3:
-			return ProgramParam::PARAM_VECTOR3;		
-		break;
-		case GL_FLOAT_VEC4:
-			return ProgramParam::PARAM_COLOR;
-		break;
-		case GL_INT:
-			return ProgramParam::PARAM_NUMBER;
-		break;
-		case GL_INT_VEC2:
-			return ProgramParam::PARAM_VECTOR2;
-		break;
-		case GL_INT_VEC3:
-			return ProgramParam::PARAM_VECTOR3;		
-		break;
-		case GL_INT_VEC4:
-			return ProgramParam::PARAM_COLOR;		
-		break;
-		case GL_BOOL:
-			return ProgramParam::PARAM_NUMBER;
-		break;
-		case GL_BOOL_VEC2:
-			return ProgramParam::PARAM_VECTOR2;		
-		break;
-		case GL_BOOL_VEC3:
-			return ProgramParam::PARAM_VECTOR3;		
-		break;
-		case GL_BOOL_VEC4:
-			return ProgramParam::PARAM_COLOR;
-		break;
-		case GL_FLOAT_MAT2:
-			return ProgramParam::PARAM_MATRIX;
-		break;
-		case GL_FLOAT_MAT3:
-			return ProgramParam::PARAM_MATRIX;		
-		break;
-		case GL_FLOAT_MAT4:
-			return ProgramParam::PARAM_MATRIX;		
-		break;
-		default:
-			return ProgramParam::PARAM_UNKNOWN;
-		break;
-	}
-}
-
-void GLSLShader::linkProgram() {
-	expectedParams.clear();
-	expectedTextures.clear();
-	expectedCubemaps.clear();
-
-	shader_id = glCreateProgram();
-    glAttachShader(shader_id, ((GLSLProgram*)fp)->program);
-    glAttachShader(shader_id, ((GLSLProgram*)vp)->program);	
-	glBindAttribLocation(shader_id, 6, "vTangent");
-	glBindAttribLocation(shader_id, 7, "vBoneWeights");
-	glBindAttribLocation(shader_id, 8, "vBoneIndices");
-    glLinkProgram(shader_id);
-	if(vp) {
-		vp->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
-	}
-	if(fp) {
-		fp->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
-	}
-	
-	int total = -1;
-	glGetProgramiv( shader_id, GL_ACTIVE_UNIFORMS, &total ); 
-	for(int i=0; i < total; i++)  {
-		int name_len=-1, num=-1;
-		GLenum type = GL_ZERO;
-		char name[128];
-		glGetActiveUniform(shader_id, GLuint(i), sizeof(name)-1, &name_len, &num, &type, name );
-		name[name_len] = 0;
-		
-		if(!(String(name).find("gl_") == 0)) {
-		switch(type) {
-			case GL_SAMPLER_2D:
-				expectedTextures.push_back(String(name));
-				printf("Shader %s expecting texture: %s\n", this->getName().c_str(), name);
-			break;
-			case GL_SAMPLER_CUBE:
-				expectedCubemaps.push_back(String(name));
-				printf("Shader %s expecting cubemap: %s\n", this->getName().c_str(), name);
-			break;			
-			default:
-				ProgramParam param;
-				param.name = String(name);
-				param.type = getPolycodeParamType(type);
-				expectedParams.push_back(param);
-				printf("Shader %s expecting param glType 0x%x, polycode type %d: %s\n", this->getName().c_str(), type, param.type, name);
-			break;
-		}
-		}
-	}	
-	
-	dispatchEvent(new Event(), Event::RESOURCE_RELOAD_EVENT);
-}
-
-void GLSLShader::unlinkProgram() {
-	if(vp) {
-		vp->removeAllHandlersForListener(this);
-	}
-	if(fp) {
-		fp->removeAllHandlersForListener(this);
-	}
-	glDetachShader(shader_id, ((GLSLProgram*)fp)->program);
-    glDetachShader(shader_id, ((GLSLProgram*)vp)->program);
-	glDeleteProgram(shader_id);	
-}
-
-void GLSLShader::handleEvent(Event *event) {
-	if(event->getEventCode() == Event::RESOURCE_RELOAD_EVENT && (event->getDispatcher() == vp || event->getDispatcher() == fp)) {
-		unlinkProgram();
-		linkProgram();
-	}
-}
-
-void GLSLShader::setVertexProgram(ShaderProgram *vp) {
-	unlinkProgram();
-	this->vp = vp;
-	linkProgram();
-}
-
-void GLSLShader::setFragmentProgram(ShaderProgram *fp) {
-	unlinkProgram();
-	this->fp = fp;
-	linkProgram();
-}
-
-
-GLSLShader::GLSLShader(GLSLProgram *vp, GLSLProgram *fp) : Shader(Shader::MODULE_SHADER) {
-	this->vp = vp;
-	this->fp = fp;
-	
-	linkProgram();
-}
-
-void GLSLShader::reload() {
-	glDeleteProgram(shader_id);
-	linkProgram();
-}
-
-GLSLShader::~GLSLShader() {
-	unlinkProgram();
-}

Core/Contents/Source/PolyGLSLShaderModule.cpp

@@ -1,533 +0,0 @@
-/*
-Copyright (C) 2011 by Ivan Safrin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-
-#include "PolyGLHeaders.h"
-
-#include "PolyGLSLShaderModule.h"
-#include "PolyCoreServices.h"
-#include "PolyCore.h"
-#include "PolyResourceManager.h"
-#include "PolyRenderer.h"
-#include "PolyGLSLProgram.h"
-#include "PolyGLSLShader.h"
-#include "PolyGLCubemap.h"
-#include "PolyMaterial.h"
-#include "PolyGLTexture.h"
-
-#include "tinyxml.h"
-
-using std::vector;
-
-using namespace Polycode;
-
-#if defined(_WINDOWS) && !defined(_MINGW)
-PFNGLUSEPROGRAMPROC glUseProgram;
-PFNGLUNIFORM1IPROC glUniform1i;
-PFNGLUNIFORM1FPROC glUniform1f;
-PFNGLUNIFORM2FPROC glUniform2f;
-PFNGLUNIFORM3FPROC glUniform3f;
-PFNGLUNIFORM4FPROC glUniform4f;
-extern PFNGLACTIVETEXTUREPROC glActiveTexture;
-PFNGLCREATESHADERPROC glCreateShader;
-PFNGLSHADERSOURCEPROC glShaderSource;
-PFNGLCOMPILESHADERPROC glCompileShader;
-PFNGLCREATEPROGRAMPROC glCreateProgram;
-PFNGLATTACHSHADERPROC glAttachShader;
-PFNGLLINKPROGRAMPROC glLinkProgram;
-PFNGLDETACHSHADERPROC glDetachShader;
-PFNGLDELETESHADERPROC glDeleteShader;
-PFNGLDELETEPROGRAMPROC glDeleteProgram;
-
-PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
-PFNGLGETSHADERIVPROC glGetShaderiv;
-PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
-PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocation;
-#endif
-
-GLSLShaderModule::GLSLShaderModule() : PolycodeShaderModule() {
-#ifdef _WINDOWS
-	glUseProgram   = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram");
-	glUniform1i = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i");
-	glUniform1f = (PFNGLUNIFORM1FPROC)wglGetProcAddress("glUniform1f");	
-	glUniform2f = (PFNGLUNIFORM2FPROC)wglGetProcAddress("glUniform2f");	
-	glUniform3f = (PFNGLUNIFORM3FPROC)wglGetProcAddress("glUniform3f");
-	glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
-	glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
-	glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
-	glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram");
-	glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader");
-	glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram");
-	glDetachShader = (PFNGLDETACHSHADERPROC)wglGetProcAddress("glDetachShader");
-	glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
-	glDeleteProgram = (PFNGLDELETEPROGRAMPROC)wglGetProcAddress("glDeleteProgram");
-
-	glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv");
-	glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
-	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
-
-#ifndef _MINGW
-	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONARBPROC)wglGetProcAddress("glGetUniformLocation");
-	glUniform4f = (PFNGLUNIFORM4FPROC)wglGetProcAddress("glUniform4f");
-#endif
-#endif
-}
-
-GLSLShaderModule::~GLSLShaderModule() {
-
-}
-
-bool GLSLShaderModule::acceptsExtension(const String& extension) {
-	if(extension == "vert" || extension == "frag") {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-String GLSLShaderModule::getShaderType() {
-	return "glsl";
-}
-
-Shader *GLSLShaderModule::createShader(ResourcePool *resourcePool, String name, String vpName, String fpName) {
-
-	GLSLShader *retShader = NULL;
-
-	GLSLProgram *vp = NULL;
-	GLSLProgram *fp = NULL;
-
-	vp = (GLSLProgram*)resourcePool->getResourceByPath(vpName);
-	fp = (GLSLProgram*)resourcePool->getResourceByPath(fpName);
-		
-	if(vp != NULL && fp != NULL) {
-		GLSLShader *shader = new GLSLShader(vp,fp);
-		shader->setName(name);
-		retShader = shader;
-		shaders.push_back((Shader*)shader);
-	}
-	return retShader;
-}
-
-Shader *GLSLShaderModule::createShader(ResourcePool *resourcePool, TiXmlNode *node) {
-	TiXmlNode* pChild;
-	GLSLProgram *vp = NULL;
-	GLSLProgram *fp = NULL;
-	GLSLShader *retShader = NULL;
-			
-	TiXmlElement *nodeElement = node->ToElement();
-	if (!nodeElement) return NULL; // Skip comment nodes
-	
-	for (pChild = node->FirstChild(); pChild != 0; pChild = pChild->NextSibling()) {
-		TiXmlElement *pChildElement = pChild->ToElement();
-		if (!pChildElement) continue; // Skip comment nodes
-		
-		if(strcmp(pChild->Value(), "vp") == 0) {
-			String vpFileName = String(pChildElement->Attribute("source"));
-			vp = (GLSLProgram*)resourcePool->getResourceByPath(vpFileName);
-			if(!vp) {
-				vp = (GLSLProgram*)CoreServices::getInstance()->getMaterialManager()->createProgramFromFile(vpFileName);
-				if(vp) {
-					vp->setResourcePath(vpFileName);
-					OSFileEntry entry = OSFileEntry(vpFileName, OSFileEntry::TYPE_FILE);
-					vp->setResourceName(entry.name);
-					resourcePool->addResource(vp);
-				}
-			}
-		}
-		if(strcmp(pChild->Value(), "fp") == 0) {
-			String fpFileName = String(pChildElement->Attribute("source"));		
-			fp = (GLSLProgram*)resourcePool->getResourceByPath(fpFileName);
-			if(!fp) {
-				fp = (GLSLProgram*)CoreServices::getInstance()->getMaterialManager()->createProgramFromFile(fpFileName);
-				if(fp) {
-					fp->setResourcePath(fpFileName);
-					OSFileEntry entry = OSFileEntry(fpFileName, OSFileEntry::TYPE_FILE);					
-					fp->setResourceName(entry.name);
-					resourcePool->addResource(fp);				
-				}
-			}			
-		}
-		
-	}
-	if(vp != NULL && fp != NULL) {
-		GLSLShader *cgShader = new GLSLShader(vp,fp);
-		cgShader->setName(String(nodeElement->Attribute("name")));
-		retShader = cgShader;
-		shaders.push_back((Shader*)cgShader);
-	}
-	return retShader;
-
-}
-
-void GLSLShaderModule::clearShader() {
-	glUseProgram(0);
-}
-
-void setUniformMatrix(GLint paramLocation, const Polycode::Matrix4& matrix) {
-#ifdef POLYCODE_NUMBER_IS_SINGLE
-	glUniformMatrix4fv(paramLocation, 1, false, matrix.ml);
-#else
-	// no glUniformMatrix4dv on some systems
-	float copyMatrix[16];
-	for(int i=0; i < 16; i++) {
-		copyMatrix[i] = matrix.ml[i];
-	}
-	glUniformMatrix4fv(paramLocation, 1, false, copyMatrix);
-#endif
-}
-
-void GLSLShaderModule::updateGLSLParam(Renderer *renderer, GLSLShader *glslShader, ProgramParam &param, ShaderBinding *materialOptions, ShaderBinding *localOptions) {
-	
-		LocalShaderParam *localParam = NULL;		
-		localParam = materialOptions->getLocalParamByName(param.name);
-		
-		// local options override material options.
-		LocalShaderParam *localOptionsParam = localOptions->getLocalParamByName(param.name);
-		if(localOptionsParam) {
-			localParam = localOptionsParam;
-		}
-
-		int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
-					
-		switch(param.type) {
-			case ProgramParam::PARAM_NUMBER:
-				if(localParam) {
-					glUniform1f(paramLocation, localParam->getNumber());				
-				} else {
-					glUniform1f(paramLocation, 0.0f);
-				}
-			break;
-			case ProgramParam::PARAM_VECTOR2:
-				if(localParam) {
-					Vector2 vec2 = localParam->getVector2();
-					glUniform2f(paramLocation, vec2.x, vec2.y);
-				} else {
-					glUniform2f(paramLocation, 0.0f, 0.0f);
-				}				
-			break;
-			case ProgramParam::PARAM_VECTOR3:
-				if(localParam) {
-					Vector3 vec3 = localParam->getVector3();
-					glUniform3f(paramLocation, vec3.x, vec3.y, vec3.z);
-				} else {
-					glUniform3f(paramLocation, 0.0f, 0.0f, 0.0f);
-				}
-			break;
-			case ProgramParam::PARAM_COLOR:
-				if(localParam) {
-					Color color = localParam->getColor();
-					glUniform4f(paramLocation, color.r, color.g, color.b, color.a);
-				} else {
-					glUniform4f(paramLocation, 0.0f, 0.0f, 0.0f, 0.0f);
-				}
-			break;
-			case ProgramParam::PARAM_MATRIX:
-				if(localParam) {
-                    if(localParam->arraySize > 0) {
-                        Matrix4 *matPointer = (Matrix4*)localParam->data;
-                        std::vector<float> matrixData;
-                        for(int i=0; i < localParam->arraySize; i++) {
-                            for(int j=0; j < 16; j++) {
-                                matrixData.push_back(matPointer[i].ml[j]);
-                            }
-                        }
-                        
-                        glUniformMatrix4fv(paramLocation, localParam->arraySize, false, &matrixData[0]);
-                    
-                    } else {
-                        setUniformMatrix(paramLocation, localParam->getMatrix4());
-                    }
-                } else {
-					Matrix4 defaultMatrix;
-					setUniformMatrix(paramLocation, defaultMatrix);
-				}
-			break;
-		}
-}
-
-bool GLSLShaderModule::applyShaderMaterial(Renderer *renderer, Material *material, ShaderBinding *localOptions, unsigned int shaderIndex) {	
-
-	GLSLShader *glslShader = (GLSLShader*)material->getShader(shaderIndex);
-
-	glPushMatrix();
-	glLoadIdentity();
-		
-	int numRendererPointLights = renderer->getNumPointLights();
-	int numRendererSpotLights = renderer->getNumSpotLights();
-	
-	int numTotalLights = glslShader->numPointLights + glslShader->numSpotLights;
-		
-	for(int i=0 ; i < numTotalLights; i++) {
-		GLfloat resetData[] = {0.0, 0.0, 0.0, 0.0};				
-		glLightfv (GL_LIGHT0+i, GL_DIFFUSE, resetData);	
-		glLightfv (GL_LIGHT0+i, GL_SPECULAR, resetData);			
-		glLightfv (GL_LIGHT0+i, GL_AMBIENT, resetData);	
-		glLightfv (GL_LIGHT0+i, GL_POSITION, resetData);	
-		glLightf (GL_LIGHT0+i, GL_SPOT_CUTOFF, 180);		
-		glLightf (GL_LIGHT0+i, GL_CONSTANT_ATTENUATION,1.0);			
-		glLightf (GL_LIGHT0+i, GL_LINEAR_ATTENUATION,0.0);			
-		glLightf (GL_LIGHT0+i, GL_QUADRATIC_ATTENUATION, 0.0);			
-	}
-	
-	int lightIndex = 0;
-	
-	vector<LightInfo> pointLights = renderer->getPointLights();
-		
-	GLfloat ambientVal[] = {1, 1, 1, 1.0};				
-	for(int i=0; i < glslShader->numPointLights; i++) {
-		LightInfo light;
-		if(i < numRendererPointLights) {
-			light = pointLights[i];
-			light.position = renderer->getCameraMatrix().Inverse() * light.position;
-			ambientVal[0] = renderer->ambientColor.r;
-			ambientVal[1] = renderer->ambientColor.g;
-			ambientVal[2] = renderer->ambientColor.b;										
-            ambientVal[3] = 1;
-            
-            GLfloat data4[] = {light.color.x * light.intensity, light.color.y * light.intensity, light.color.z * light.intensity, 1.0};
-            glLightfv (GL_LIGHT0+lightIndex, GL_DIFFUSE, data4);
-            
-            data4[0] = light.specularColor.r* light.intensity;
-            data4[1] = light.specularColor.g* light.intensity;
-            data4[2] = light.specularColor.b* light.intensity;
-            data4[3] = light.specularColor.a* light.intensity;
-            glLightfv (GL_LIGHT0+lightIndex, GL_SPECULAR, data4);				
-                
-            data4[3] = 1.0;
-                
-            glLightfv (GL_LIGHT0+lightIndex, GL_AMBIENT, ambientVal);		
-            glLightf (GL_LIGHT0+lightIndex, GL_SPOT_CUTOFF, 180);
-
-            data4[0] = light.position.x;
-            data4[1] = light.position.y;
-            data4[2] = light.position.z;
-            glLightfv (GL_LIGHT0+lightIndex, GL_POSITION, data4);		
-
-            glLightf (GL_LIGHT0+lightIndex, GL_CONSTANT_ATTENUATION, light.constantAttenuation);		
-            glLightf (GL_LIGHT0+lightIndex, GL_LINEAR_ATTENUATION, light.linearAttenuation);				
-            glLightf (GL_LIGHT0+lightIndex, GL_QUADRATIC_ATTENUATION, light.quadraticAttenuation);				
-            lightIndex++;
-		}
-	}
-
-	vector<LightInfo> spotLights = renderer->getSpotLights();
-//	vector<Texture*> shadowMapTextures = renderer->getShadowMapTextures();	
-	char texName[32];
-	char matName[32];	
-	int shadowMapTextureIndex = 0;
-					
-	glUseProgram(glslShader->shader_id);	
-	int textureIndex = 0;					
-					
-	for(int i=0; i < glslShader->numSpotLights; i++) {
-		LightInfo light;
-		Vector3 pos;
-		Vector3 dir;
-		if(i < numRendererSpotLights) {
-			light = spotLights[i];
-			pos = light.position;
-			dir = light.dir;						
-			pos = renderer->getCameraMatrix().Inverse() * pos;
-			dir = renderer->getCameraMatrix().Inverse().rotateVector(dir);
-			
-			ambientVal[0] = renderer->ambientColor.r;
-			ambientVal[1] = renderer->ambientColor.g;
-			ambientVal[2] = renderer->ambientColor.b;										
-			ambientVal[3] = 1;
-		
-            GLfloat data4[] = {light.color.x * light.intensity, light.color.y * light.intensity, light.color.z * light.intensity, 1.0};
-            glLightfv (GL_LIGHT0+lightIndex, GL_DIFFUSE, data4);
-            
-            data4[0] = light.specularColor.r* light.intensity;
-            data4[1] = light.specularColor.g* light.intensity;
-            data4[2] = light.specularColor.b* light.intensity;
-            data4[3] = light.specularColor.a* light.intensity;
-            glLightfv (GL_LIGHT0+lightIndex, GL_SPECULAR, data4);		
-                
-            data4[3] = 1.0;			
-                
-            glLightfv (GL_LIGHT0+lightIndex, GL_AMBIENT, ambientVal);		
-            glLightf (GL_LIGHT0+lightIndex, GL_SPOT_CUTOFF, light.spotlightCutoff);
-
-            glLightf (GL_LIGHT0+lightIndex, GL_SPOT_EXPONENT, light.spotlightExponent);
-            
-            data4[0] = dir.x;
-            data4[1] = dir.y;
-            data4[2] = dir.z;
-            glLightfv (GL_LIGHT0+lightIndex, GL_SPOT_DIRECTION, data4);
-
-            data4[0] = pos.x;
-            data4[1] = pos.y;
-            data4[2] = pos.z;
-            glLightfv (GL_LIGHT0+lightIndex, GL_POSITION, data4);		
-
-            glLightf (GL_LIGHT0+lightIndex, GL_CONSTANT_ATTENUATION, light.constantAttenuation);		
-            glLightf (GL_LIGHT0+lightIndex, GL_LINEAR_ATTENUATION, light.linearAttenuation);				
-            glLightf (GL_LIGHT0+lightIndex, GL_QUADRATIC_ATTENUATION, light.quadraticAttenuation);				
-            
-            Number shadowAmount = 0.0;
-            
-            if(light.shadowsEnabled) {
-                if(shadowMapTextureIndex < 4) {
-                    switch(shadowMapTextureIndex) {
-                        case 0:
-                            strcpy(texName, "shadowMap0");
-                            strcpy(matName, "shadowMatrix0");						
-                        break;
-                        case 1:
-                            strcpy(texName, "shadowMap1");
-                            strcpy(matName, "shadowMatrix1");												
-                        break;
-                        case 2:
-                            strcpy(texName, "shadowMap2");
-                            strcpy(matName, "shadowMatrix2");																		
-                        break;
-                        case 3:
-                            strcpy(texName, "shadowMap3");
-                            strcpy(matName, "shadowMatrix3");																		
-                        break;							
-                    }
-                
-                    int texture_location = glGetUniformLocation(glslShader->shader_id, texName);
-                    glUniform1i(texture_location, textureIndex);
-                    glActiveTexture(GL_TEXTURE0 + textureIndex);		
-                    glBindTexture(GL_TEXTURE_2D, ((OpenGLTexture*)light.shadowMapTexture)->getTextureID());	
-                    textureIndex++;
-            
-                    LocalShaderParam *matParam = material->getShaderBinding(shaderIndex)->getLocalParamByName(matName);
-                    if(matParam) {
-                        matParam->setMatrix4(light.textureMatrix);
-                    }
-                    
-                    shadowAmount = 1.0;
-                    
-                }
-                
-                shadowMapTextureIndex++;
-            }
-            
-            LocalShaderParam *amountParam = material->getShaderBinding(shaderIndex)->getLocalParamByName("shadowAmount");
-            if(amountParam) {
-                amountParam->setNumber(shadowAmount);
-            }
-            
-            lightIndex++;
-		}
-	}
-	glPopMatrix();
-		
-	glEnable(GL_TEXTURE_2D);
-
-	Matrix4 modelMatrix = renderer->getModelviewMatrix() * renderer->getCameraMatrix();
-    LocalShaderParam *modelMatrixParam = material->getShaderBinding(shaderIndex)->getLocalParamByName("modelMatrix");
-    
-    if(modelMatrixParam) {
-        modelMatrixParam->setMatrix4(modelMatrix);
-    }
-    
-	ShaderBinding *cgBinding = material->getShaderBinding(shaderIndex);
-	
-	for(int i=0; i < glslShader->expectedParams.size(); i++) {
-		ProgramParam param = glslShader->expectedParams[i];
-		updateGLSLParam(renderer, glslShader, param, material->getShaderBinding(shaderIndex), localOptions);
-	}
-		
-	for(int i=0; i < cgBinding->textures.size(); i++) {
-        if(!localOptions->getTexture(cgBinding->textures[i].name)) {
-            OpenGLTexture *glTexture = (OpenGLTexture*)cgBinding->textures[i].texture;
-            if(glTexture) {		
-                int texture_location = glGetUniformLocation(glslShader->shader_id, cgBinding->textures[i].name.c_str());
-                glUniform1i(texture_location, textureIndex);
-                glActiveTexture(GL_TEXTURE0 + textureIndex);		
-                glBindTexture(GL_TEXTURE_2D, glTexture->getTextureID());
-                textureIndex++;
-            }
-        }
-	}
-			
-	for(int i=0; i < cgBinding->cubemaps.size(); i++) {
-        if(!localOptions->getCubemap(cgBinding->cubemaps[i].name)) {
-            OpenGLCubemap *glCubemap = (OpenGLCubemap*)cgBinding->cubemaps[i].cubemap;
-            if(glCubemap) {
-                int texture_location = glGetUniformLocation(glslShader->shader_id, cgBinding->cubemaps[i].name.c_str());
-                glUniform1i(texture_location, textureIndex);		
-                glActiveTexture(GL_TEXTURE0 + textureIndex);				
-                glBindTexture(GL_TEXTURE_CUBE_MAP, glCubemap->getTextureID());
-                textureIndex++;
-            }
-        }
-	}
-	
-	for(int i=0; i < localOptions->textures.size(); i++) {
-		OpenGLTexture *glTexture = (OpenGLTexture*)localOptions->textures[i].texture;
-		if(glTexture) {		
-			int texture_location = glGetUniformLocation(glslShader->shader_id, localOptions->textures[i].name.c_str());
-			glUniform1i(texture_location, textureIndex);
-			glActiveTexture(GL_TEXTURE0 + textureIndex);		
-			glBindTexture(GL_TEXTURE_2D, glTexture->getTextureID());	
-			textureIndex++;
-		}
-	}		
-
-	for(int i=0; i < localOptions->cubemaps.size(); i++) {
-		OpenGLCubemap *glCubemap = (OpenGLCubemap*)localOptions->cubemaps[i].cubemap;
-		if(glCubemap) {
-			int texture_location = glGetUniformLocation(glslShader->shader_id, localOptions->cubemaps[i].name.c_str());
-			glUniform1i(texture_location, textureIndex);
-			glActiveTexture(GL_TEXTURE0 + textureIndex);				
-			glBindTexture(GL_TEXTURE_CUBE_MAP, glCubemap->getTextureID());
-			textureIndex++;
-		}
-	}	
-
-		 
-	return true;
-}
-
-void GLSLShaderModule::reloadPrograms() {
-	for(int i=0; i < programs.size(); i++) {
-		GLSLProgram *program = programs[i];
-		program->reloadProgram();	
-	}	
-}
-
-GLSLProgram *GLSLShaderModule::createGLSLProgram(const String& fileName, int type) {
-	GLSLProgram *prog = new GLSLProgram(fileName, type);	
-	programs.push_back(prog);
-	return prog;
-}
-
-ShaderProgram* GLSLShaderModule::createProgramFromFile(const String& extension, const String& fullPath) {
-	if(extension == "vert") {
-		Logger::log("Adding GLSL vertex program %s\n", fullPath.c_str());				
-		return createGLSLProgram(fullPath, GLSLProgram::TYPE_VERT);
-	}
-	if(extension == "frag") {
-		Logger::log("Adding GLSL fragment program %s\n", fullPath.c_str());
-		return createGLSLProgram(fullPath, GLSLProgram::TYPE_FRAG);								
-	}
-	return NULL;
-}

Core/Contents/Source/PolyGLTexture.cpp

@@ -1,144 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolyGLHeaders.h"
-
-#include "PolyGLTexture.h"
-#include "PolyCoreServices.h"
-#include "PolyRenderer.h"
-
-using namespace Polycode;
-
-#ifdef _WINDOWS
-extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
-#endif
-
-OpenGLTexture::OpenGLTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int filteringMode, int type) : Texture(width, height, textureData,clamp, createMipmaps, type) {
-	this->filteringMode = filteringMode;
-	glTextureLoaded = false;
-	frameBufferID = FRAMEBUFFER_NULL;
-	
-	switch(type) {
-		case Image::IMAGE_RGB:
-			glTextureType = GL_RGB;
-			glTextureFormat = GL_RGB;				
-			pixelType = GL_UNSIGNED_BYTE;			
-		break;
-		case Image::IMAGE_FP16:
-			glTextureType = GL_RGB;
-			glTextureFormat = GL_RGB;
-			pixelType = GL_FLOAT;
-		break;		
-		default:
-			glTextureType = GL_RGBA;
-			glTextureFormat = GL_RGBA;	
-			pixelType = GL_UNSIGNED_BYTE;	
-		break;
-	}
-		
-	recreateFromImageData();
-}
-
-void OpenGLTexture::recreateFromImageData() {
-    
-    if(!textureData) {
-        return;
-    }
-	
-	Number anisotropy = CoreServices::getInstance()->getRenderer()->getAnisotropyAmount();
-	
-	if (!glTextureLoaded) {
-		glGenTextures(1, &textureID);
-	}
-	
-	glBindTexture(GL_TEXTURE_2D, textureID);
-	
-	if(clamp) {
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-	} else {
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);	
-	}
-	switch(filteringMode) {
-		case Renderer::TEX_FILTERING_LINEAR:
-		
-			if(anisotropy > 0) {
-				glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
-			}
-		
-			if(createMipmaps) {
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-				if(textureData) {
-					gluBuild2DMipmaps(GL_TEXTURE_2D, glTextureFormat, width, height, glTextureType, pixelType, textureData );
-				}
-			} else {
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);		
-				if(textureData) {
-					glTexImage2D(GL_TEXTURE_2D, 0, glTextureFormat, width, height, 0, glTextureType, pixelType, textureData);							
-				}						
-			}
-			break;
-		case Renderer::TEX_FILTERING_NEAREST:
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);		
-			if(textureData) {
-				glTexImage2D(GL_TEXTURE_2D, 0, glTextureFormat, width, height, 0, glTextureType, pixelType, textureData);							
-			}			
-			break;
-	}	
-	
-	glTextureLoaded = true;
-}
-
-OpenGLTexture::OpenGLTexture(unsigned int width, unsigned int height) : Texture(width, height, NULL ,true, true) {
-
-}
-
-void OpenGLTexture::setGLInfo(GLuint textureID, GLuint frameBufferID) {
-	this->textureID = textureID;
-	this->frameBufferID = frameBufferID;
-}
-
-void OpenGLTexture::setTextureData(char *data) {
-	memcpy(textureData, data, width * height * pixelSize);
-
-	glBindTexture(GL_TEXTURE_2D, textureID);
-	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, glTextureType, pixelType, textureData);	
-}
-
-OpenGLTexture::~OpenGLTexture() {
-	glDeleteTextures(1, &textureID);
-	if(frameBufferID != FRAMEBUFFER_NULL) {
-		glDeleteFramebuffersEXT(1, &frameBufferID);
-	}	
-}
-
-GLuint OpenGLTexture::getFrameBufferID() {
-	return frameBufferID;
-}
-
-GLuint OpenGLTexture::getTextureID() {
-	return textureID;
-}

Core/Contents/Source/PolyGLVertexBuffer.cpp

@@ -1,160 +0,0 @@
-/*
- Copyright (C) 2011 by Ivan Safrin
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
-*/
-
-#include "PolyGLHeaders.h"
-#include "PolyGLVertexBuffer.h"
-
-#if defined(__APPLE__) && defined(__MACH__)
-
-#else
-	#include "malloc.h"
-#endif
-
-using namespace Polycode;
-
-#ifdef _WINDOWS
-// ARB_vertex_buffer_object
-extern PFNGLBINDBUFFERARBPROC glBindBufferARB;
-extern PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB;
-extern PFNGLGENBUFFERSARBPROC glGenBuffersARB;
-extern PFNGLISBUFFERARBPROC glIsBufferARB;
-extern PFNGLBUFFERDATAARBPROC glBufferDataARB;
-extern PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB;
-extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB;
-extern PFNGLMAPBUFFERARBPROC glMapBufferARB;
-extern PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB;
-extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB;
-extern PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB;
-#endif
-
-OpenGLVertexBuffer::OpenGLVertexBuffer(Mesh *mesh) : VertexBuffer() {
-	
-    vertexBufferID = -1;
-    texCoordBufferID = -1;
-    normalBufferID = -1;
-    colorBufferID = -1;
-    tangentBufferID = -1;
-    indexBufferID = -1;
-    boneWeightBufferID = -1;
-    boneIndexBufferID = -1;
-    
-    
-	meshType = mesh->getMeshType();
-    vertexCount = mesh->vertexPositionArray.getDataSize() / 3;
-
-	glGenBuffersARB(1, &vertexBufferID);
-	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertexBufferID);
-    
-    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->vertexPositionArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexPositionArray.getArrayData(), GL_STATIC_DRAW_ARB);
-
-    
-    if(mesh->vertexTexCoordArray.getDataSize() == vertexCount * 2) {
-        glGenBuffersARB(1, &texCoordBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, texCoordBufferID);
-            
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexTexCoordArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexTexCoordArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->vertexNormalArray.getDataSize() == vertexCount * 3) {
-        glGenBuffersARB(1, &normalBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, normalBufferID);
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexNormalArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexNormalArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->vertexTangentArray.getDataSize() == vertexCount * 3) {
-        glGenBuffersARB(1, &tangentBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, tangentBufferID);
-        
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexTangentArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexTangentArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->vertexBoneWeightArray.getDataSize() == vertexCount * 4) {
-        glGenBuffersARB(1, &boneWeightBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, boneWeightBufferID);
-        
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexBoneWeightArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexBoneWeightArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->vertexBoneIndexArray.getDataSize() == vertexCount * 4) {
-        glGenBuffersARB(1, &boneIndexBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, boneIndexBufferID);
-        
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexBoneIndexArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexBoneIndexArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->vertexColorArray.getDataSize() == vertexCount * 4) {
-        glGenBuffersARB(1, &colorBufferID);
-        glBindBufferARB(GL_ARRAY_BUFFER_ARB, colorBufferID);
-            
-        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  mesh->vertexColorArray.getDataSize() * sizeof(PolyRendererVertexType), mesh->vertexColorArray.getArrayData(), GL_STATIC_DRAW_ARB);
-    }
-    
-    if(mesh->indexedMesh && mesh->indexArray.getDataSize() > 0) {
-        glGenBuffersARB(1, &indexBufferID);
-        glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexBufferID);
-        glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,  mesh->indexArray.getDataSize() * sizeof(PolyRendererIndexType), mesh->indexArray.getArrayData(), GL_STATIC_DRAW_ARB);
-        indexCount = mesh->indexArray.getDataSize();
-    }
-    
-}
-
-OpenGLVertexBuffer::~OpenGLVertexBuffer() {
-	glDeleteBuffersARB(1, &vertexBufferID);
-	glDeleteBuffersARB(1, &texCoordBufferID);
-	glDeleteBuffersARB(1, &normalBufferID);
-	glDeleteBuffersARB(1, &colorBufferID);
-	glDeleteBuffersARB(1, &indexBufferID);
-	glDeleteBuffersARB(1, &boneWeightBufferID);
-	glDeleteBuffersARB(1, &boneIndexBufferID);
-}
-
-GLuint OpenGLVertexBuffer::getBoneWeightBufferID() {
-    return boneWeightBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getBoneIndexBufferID() {
-    return boneIndexBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getColorBufferID() {
-	return colorBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getNormalBufferID() {
-	return normalBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getTextCoordBufferID() {
-	return texCoordBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getVertexBufferID() {
-	return vertexBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getTangentBufferID() {
-	return tangentBufferID;
-}
-
-GLuint OpenGLVertexBuffer::getIndexBufferID() {
-    return indexBufferID;
-}

Core/Contents/Source/PolyModule.cpp → Core/Contents/Source/PolyGPUDrawBuffer.cpp

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2011 by Ivan Safrin
+ Copyright (C) 2015 by Ivan Safrin
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -18,29 +18,16 @@
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
-*/
+ */
 
-#include "PolyModule.h"
+#include "PolyGPUDrawBuffer.h"
 
 using namespace Polycode;
 
-PolycodeModule::PolycodeModule() {
-	type = TYPE_GENERIC;
-	_requiresUpdate = false;
+GPUDrawBuffer::GPUDrawBuffer() {
+    
 }
 
-PolycodeModule::~PolycodeModule() {
-	
-}
-
-bool PolycodeModule::requiresUpdate() {
-	return _requiresUpdate;
-}
-
-PolycodeShaderModule::PolycodeShaderModule() : PolycodeModule() {
-	type = TYPE_SHADER;
-}
-
-PolycodeShaderModule::~PolycodeShaderModule() {
-
+GPUDrawBuffer::~GPUDrawBuffer() {
+    
 }

Core/Contents/Source/PolyMaterial.cpp

@@ -83,6 +83,9 @@ void Material::recreateRenderTargets() {
 }
 
 void Material::recreateRenderTarget(ShaderRenderTarget *renderTarget) {
+    
+    // RENDERER_TODO
+    /*
 	int textureWidth;
 	int textureHeight;
 	Texture *newTexture;
@@ -113,6 +116,7 @@ void Material::recreateRenderTarget(ShaderRenderTarget *renderTarget) {
 	}
 	
 	CoreServices::getInstance()->getRenderer()->createRenderTextures(&newTexture, NULL, textureWidth, textureHeight, fp16RenderTargets);
+    
 	newTexture->setResourceName(renderTarget->id);
 	
 	Texture *oldTexture = renderTarget->texture;
@@ -132,9 +136,12 @@ void Material::recreateRenderTarget(ShaderRenderTarget *renderTarget) {
 		
 		CoreServices::getInstance()->getRenderer()->destroyTexture(oldTexture);
 	}
+    */
 }
 
 void Material::handleEvent(Event *event) {
+    // RENDERER_TODO
+    /*
 	//Fix the bindings when we detect a reload
 	for (int i = 0; i < materialShaders.size(); i++) {
 		Shader* shader = materialShaders[i];
@@ -148,6 +155,7 @@ void Material::handleEvent(Event *event) {
 		}
 	}
 	dispatchEvent(new Event(), Event::RESOURCE_RELOAD_EVENT);	
+     */
 }
 
 void Material::removeShader(int shaderIndex) {
@@ -158,6 +166,8 @@ void Material::removeShader(int shaderIndex) {
 }
 
 void Material::addShaderAtIndex(Shader *shader,ShaderBinding *shaderBinding, int shaderIndex) {
+        // RENDERER_TODO
+    /*
 	materialShaders.insert(materialShaders.begin()+shaderIndex, shader);
 	shaderBindings.insert(shaderBindings.begin()+shaderIndex, shaderBinding);
 	
@@ -169,9 +179,12 @@ void Material::addShaderAtIndex(Shader *shader,ShaderBinding *shaderBinding, int
 			shaderBinding->addParam(shader->expectedParams[i].type, shader->expectedParams[i].name);
 		}
 	}
+     */
 }
 			
 void Material::addShader(Shader *shader,ShaderBinding *shaderBinding) {
+    // RENDERER_TODO
+    /*
 	materialShaders.push_back(shader);
 	shaderBindings.push_back(shaderBinding);
 	
@@ -183,6 +196,7 @@ void Material::addShader(Shader *shader,ShaderBinding *shaderBinding) {
 			shaderBinding->addParam(shader->expectedParams[i].type, shader->expectedParams[i].name);
 		}
 	}	
+     */
 }
 
 

Core/Contents/Source/PolyMaterialManager.cpp

@@ -24,7 +24,6 @@
 #include "PolyCoreServices.h"
 #include "PolyCubemap.h"
 #include "PolyMaterial.h"
-#include "PolyModule.h"
 #include "PolyRenderer.h"
 #include "PolyResourceManager.h"
 #include "PolyFixedShader.h"
@@ -46,9 +45,7 @@ MaterialManager::~MaterialManager() {
 }
 
 void MaterialManager::Update(int elapsed) {
-	for(int i=0;i < textures.size(); i++) {
-		textures[i]->updateScroll(elapsed);
-	}
+
 }
 
 Texture *MaterialManager::getTextureByResourcePath(const String& resourcePath) const {
@@ -70,10 +67,7 @@ void MaterialManager::deleteTexture(Texture *texture) {
 }
 
 void MaterialManager::reloadPrograms() {
-	for(int m=0; m < shaderModules.size(); m++) {
-		PolycodeShaderModule *shaderModule = shaderModules[m];
-		shaderModule->reloadPrograms();
-	}
+
 	vector<Resource *> shaders = CoreServices::getInstance()->getResourceManager()->getResources(Resource::RESOURCE_SHADER);
 	for(int s = 0; s < shaders.size(); s++) {
 		Shader *shader = (Shader *)shaders[s];
@@ -106,7 +100,9 @@ void MaterialManager::loadMaterialLibraryIntoPool(ResourcePool *pool, const Stri
 
 ShaderProgram *MaterialManager::createProgramFromFile(String programPath) {
 	OSFileEntry entry(programPath, OSFileEntry::TYPE_FILE);
-	   
+
+    // RENDERER_TODO
+    /*
 	for(int m=0; m < shaderModules.size(); m++) {
 		PolycodeShaderModule *shaderModule = shaderModules[m];
 		if(shaderModule->acceptsExtension(entry.extension)) {
@@ -118,13 +114,10 @@ ShaderProgram *MaterialManager::createProgramFromFile(String programPath) {
 			return newProgram;
 		}
 	}
+     */
 	return NULL;
 }
 
-void MaterialManager::addShaderModule(PolycodeShaderModule *module) {
-	shaderModules.push_back(module);
-}
-
 #define DEFAULT_TEXTURE "default/default.png"
 
 Texture *MaterialManager::createTextureFromFile(const String& fileName, bool clamp, bool createMipmaps, ResourcePool *resourcePool) {
@@ -160,11 +153,6 @@ Texture *MaterialManager::createTextureFromFile(const String& fileName, bool cla
 	return newTexture;
 }
 
-Texture *MaterialManager::createFramebufferTexture(int width, int height, int type) {
-	Texture *newTexture = CoreServices::getInstance()->getRenderer()->createFramebufferTexture(width, height);
-	return newTexture;
-}
-
 Texture *MaterialManager::createNewTexture(int width, int height, bool clamp, bool createMipmaps, int type) {
 	Image *newImage = new Image(width, height, type);
 	newImage->fill(Color(1,1,1,1));
@@ -202,7 +190,8 @@ void MaterialManager::reloadProgramsAndTextures() {
 void MaterialManager::reloadTextures() {
 	for(int i=0; i < textures.size(); i++) {
 		Texture *texture = textures[i];
-		texture->recreateFromImageData();
+        //RENDERER_TODO
+//		texture->recreateFromImageData();
 	}
 }
 
@@ -220,12 +209,7 @@ Shader *MaterialManager::getShaderByIndex(unsigned int index) {
 Shader *MaterialManager::createShader(ResourcePool *resourcePool, String shaderType, String name, String vpName, String fpName, bool screenShader) {
 	Shader *retShader = NULL;
 	
-	for(int m=0; m < shaderModules.size(); m++) {
-		PolycodeShaderModule *shaderModule = shaderModules[m];
-		if(shaderModule->getShaderType() == shaderType) {
-			retShader = shaderModule->createShader(resourcePool, name, vpName, fpName);
-		}
-	}
+    // RENDERER_TODO
 	
 	if(retShader) {
 		retShader->screenShader = screenShader;
@@ -243,15 +227,7 @@ Shader *MaterialManager::createShaderFromXMLNode(ResourcePool *resourcePool, TiX
 	
 	Shader *retShader = NULL;
 	
-	if(nodeElement->Attribute("type")) {
-		String shaderType = nodeElement->Attribute("type");
-		for(int m=0; m < shaderModules.size(); m++) {
-			PolycodeShaderModule *shaderModule = shaderModules[m];
-			if(shaderModule->getShaderType() == shaderType) {
-				retShader = shaderModule->createShader(resourcePool, node);
-			}
-		}		
-	}
+    // RENDERER_TODO
 	
 	if (!retShader)
 		return NULL;
@@ -470,8 +446,13 @@ Material *MaterialManager::materialFromXMLNode(ResourcePool *resourcePool, TiXml
 				if(strcmp(pChild->Value(), "rendertarget") == 0) {
 					ShaderRenderTarget *newTarget = new ShaderRenderTarget;
 					newTarget->id = pChildElement->Attribute("id");
+                    
+                    // RENDERER_TODO
+                    /*
 					newTarget->width = CoreServices::getInstance()->getRenderer()->getXRes();
 					newTarget->height = CoreServices::getInstance()->getRenderer()->getYRes();
+                    */
+                    
 					newTarget->sizeMode = ShaderRenderTarget::SIZE_MODE_PIXELS;					
 					if(pChildElement->Attribute("width") && pChildElement->Attribute("height")) {
 						newTarget->width = atof(pChildElement->Attribute("width"));
@@ -517,7 +498,9 @@ Material *MaterialManager::materialFromXMLNode(ResourcePool *resourcePool, TiXml
 
 							if(strcmp(pChild2->Value(), "param") == 0){
 								String pname =  pChild2Element->Attribute("name");
-								
+
+                                    // RENDERER_TODO
+                                /*
 								if(!CoreServices::getInstance()->getRenderer()->getDataPointerForName(pname)) {								
                                     String pvalue =  pChild2Element->Attribute("value");
                                     int type = materialShader->getExpectedParamType(pname);
@@ -526,6 +509,7 @@ Material *MaterialManager::materialFromXMLNode(ResourcePool *resourcePool, TiXml
                                         param->setParamValueFromString(type, pvalue);
                                     }
 								}
+                                 */
 							}						
 						}
 					}

Core/Contents/Source/PolyOpenGLGraphicsInterface.cpp

@@ -0,0 +1,135 @@
+
+/*
+ Copyright (C) 2015 by Ivan Safrin
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+#include "PolyOpenGLGraphicsInterface.h"
+
+
+
+using namespace Polycode;
+
+OpenGLGraphicsInterface::OpenGLGraphicsInterface() {
+
+}
+
+OpenGLGraphicsInterface::~OpenGLGraphicsInterface() {
+    
+}
+
+void OpenGLGraphicsInterface::executeDrawCall(const GPUDrawCall& drawCall) {
+    
+}
+
+void OpenGLGraphicsInterface::createTexture(Texture *texture, int filteringMode, int anisotropy, bool createMipmaps) {
+    if(!texture->platformData) {
+        texture->platformData = (void*) new GLuint;
+        glGenTextures(1, (GLuint*)texture->platformData);
+    }
+    
+    GLuint textureID = *((GLuint*)texture->platformData);
+    
+    glBindTexture(GL_TEXTURE_2D, textureID);
+    
+    if(texture->clamp) {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    } else {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    }
+    
+    GLenum glTextureType;
+    GLuint glTextureFormat;
+    GLenum pixelType;
+    
+    switch(texture->type) {
+        case Image::IMAGE_RGB:
+            glTextureType = GL_RGB;
+            glTextureFormat = GL_RGB;
+            pixelType = GL_UNSIGNED_BYTE;
+            break;
+        case Image::IMAGE_FP16:
+            glTextureType = GL_RGB;
+            glTextureFormat = GL_RGB;
+            pixelType = GL_FLOAT;
+            break;
+        default:
+            glTextureType = GL_RGBA;
+            glTextureFormat = GL_RGBA;	
+            pixelType = GL_UNSIGNED_BYTE;	
+            break;
+    }
+    
+    
+    switch(filteringMode) {
+        case Renderer::TEX_FILTERING_LINEAR:
+            
+            if(anisotropy > 0) {
+                glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
+            }
+            
+            if(createMipmaps) {
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+                if(texture->getTextureData()) {
+                    gluBuild2DMipmaps(GL_TEXTURE_2D, glTextureFormat, texture->getWidth(), texture->getHeight(), glTextureType, pixelType, texture->getTextureData());
+                }
+            } else {
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                if(texture->getTextureData()) {
+                    glTexImage2D(GL_TEXTURE_2D, 0, glTextureFormat, texture->getWidth(), texture->getHeight(), 0, glTextureType, pixelType, texture->getTextureData());
+                }
+            }
+            break;
+        case Renderer::TEX_FILTERING_NEAREST:
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);		
+            if(texture->getTextureData()) {
+                glTexImage2D(GL_TEXTURE_2D, 0, glTextureFormat, texture->getWidth(), texture->getHeight(), 0, glTextureType, pixelType, texture->getTextureData());
+            }			
+            break;
+    }
+}
+
+void OpenGLGraphicsInterface::setViewport(unsigned int x,unsigned  int y,unsigned  int width, unsigned height) {
+    glViewport(x, y, width, height);
+}
+
+void OpenGLGraphicsInterface::clearBuffers(bool colorBuffer, bool depthBuffer, bool stencilBuffer) {
+    GLbitfield clearMask = 0;
+    
+    if(colorBuffer) {
+        clearMask = clearMask | GL_COLOR_BUFFER_BIT;
+    }
+    
+    if(depthBuffer) {
+        clearMask = clearMask | GL_DEPTH_BUFFER_BIT;
+    }
+    
+    if(stencilBuffer) {
+        clearMask = clearMask | GL_STENCIL_BUFFER_BIT;
+    }
+    
+    
+    glClear(clearMask);
+}

Core/Contents/Source/PolyParticleEmitter.cpp

@@ -227,7 +227,8 @@ void SceneParticleEmitter::rebuildParticles() {
         case PARTICLE_TYPE_MESH:
         case PARTICLE_TYPE_QUAD:
         {
-            Matrix4 cameraMatrix = renderer->getCameraMatrix();
+            // RENDERER_TODO
+            Matrix4 cameraMatrix;// = renderer->getCameraMatrix();
             Quaternion q;
             
             Color vertexColor;
@@ -314,10 +315,6 @@ void SceneParticleEmitter::rebuildParticles() {
             break;
             
     }
-    
-    if(useVertexBuffer) {
-		CoreServices::getInstance()->getRenderer()->createVertexBufferForMesh(mesh);
-    }
 }
 
 unsigned int SceneParticleEmitter::getParticleCount() const {

Core/Contents/Source/PolyRenderer.cpp

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2011 by Ivan Safrin
+ Copyright (C) 2015 by Ivan Safrin
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -18,351 +18,112 @@
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
-*/
+ */
+
 
 #include "PolyRenderer.h"
-#include "PolyFixedShader.h"
-#include "PolyMaterial.h"
-#include "PolyModule.h"
-#include "PolyMesh.h"
+#include "PolyCoreServices.h"
+#include "PolyCore.h"
+#include "PolyTexture.h"
 
 using namespace Polycode;
 
-Renderer::Renderer() : clearColor(0.2, 0.2, 0.2, 0.0), currentTexture(NULL), lightingEnabled(false), xRes(0), yRes(0) {
-	anisotropy = 0;
-	textureFilteringMode = TEX_FILTERING_LINEAR;
-	currentMaterial = NULL;
-	numLights = 0;
-	exposureLevel = 1;
-	shadersEnabled = true;
-	currentMaterial = NULL;
-	numLights = 0;
-	numPointLights = 0;
-	numSpotLights = 0;	
-	exposureLevel = 1;
-	shadersEnabled = true;
-	currentShaderModule = NULL;
-	setAmbientColor(0.0,0.0,0.0);
-	cullingFrontFaces = false;
-	scissorEnabled = false;
-	blendNormalAsPremultiplied = false;
-	alphaTestValue = 0.01;
-	doClearBuffer = true;
-    backingResolutionScaleX = 1.0;
-    backingResolutionScaleY = 1.0;
-    overrideMaterial = NULL;
-    renderToGlobalFramebuffer = false;
-    globalColorFramebuffer = NULL;
-    globalDepthFramebuffer = NULL;
+GPUDrawBuffer::GPUDrawBuffer() {
+    
 }
 
-void Renderer::setRenderToGlobalFramebuffer(bool val) {
-    
-    if(val == renderToGlobalFramebuffer) {
-        return;
-    }
+GPUDrawBuffer::~GPUDrawBuffer() {
     
-    renderToGlobalFramebuffer = val;
-    
-    if(renderToGlobalFramebuffer) {
-        createRenderTextures(&globalColorFramebuffer, &globalDepthFramebuffer, getXRes(), getYRes(), false);
-    } else {
-        delete globalColorFramebuffer;
-        delete globalDepthFramebuffer;
-    }
 }
 
-void Renderer::BeginRender() {
-    if(renderToGlobalFramebuffer) {
-        bindFrameBufferTexture(globalColorFramebuffer);
-        bindFrameBufferTextureDepth(globalDepthFramebuffer);
-    }
-}
 
-void Renderer::EndRender() {
-    if(renderToGlobalFramebuffer) {
-        unbindFramebuffers();
-    }
+GraphicsInterface::GraphicsInterface() {
 }
 
-bool Renderer::getRenderToGlobalFramebuffer() const {
-    return renderToGlobalFramebuffer;
+RenderThread::RenderThread() : interface(NULL) {
+    
+    options.filteringMode = Renderer::TEX_FILTERING_LINEAR;
+    options.anisotropy = 0;
+    options.createMipmaps = true;
+    
+    jobQueueMutex = Services()->getCore()->createMutex();
 }
 
-Texture *Renderer::getGlobalColorFramebuffer() const {
-    return globalColorFramebuffer;
+void RenderThread::runThread() {
+    while(threadRunning) {
+        Services()->getCore()->lockMutex(jobQueueMutex);
+        if(jobQueue.size() > 0) {
+            RendererThreadJob nextJob = jobQueue.front();
+            jobQueue.pop();
+            processJob(nextJob);
+        }
+        Services()->getCore()->unlockMutex(jobQueueMutex);
+    }
 }
 
-Texture *Renderer::getGlobalDepthFramebuffer() const {
-    return globalDepthFramebuffer;
+void RenderThread::processJob(const RendererThreadJob &job) {
+    switch(job.jobType) {
+        case JOB_REQUEST_CONTEXT_CHANGE:
+        {
+            VideoModeChangeInfo *modeInfo = (VideoModeChangeInfo*) job.data;
+            core->handleVideoModeChange(modeInfo);
+            delete modeInfo;
+        }
+        break;
+        case JOB_CREATE_TEXTURE:
+        {
+            Texture *texture = (Texture*) job.data;
+            interface->createTexture(texture, options.filteringMode, options.anisotropy, options.createMipmaps);
+        }
+        break;
+        case JOB_PROCESS_DRAW_BUFFER:
+        {
+            GPUDrawBuffer *buffer = (GPUDrawBuffer*) job.data;
+            interface->setViewport(buffer->viewport.x, buffer->viewport.y, buffer->viewport.w, buffer->viewport.h);
+            interface->clearBuffers(true, true, true);
+            delete buffer;
+        }
+        break;
+        case JOB_FLUSH_CONTEXT:
+        {
+            core->flushRenderContext();
+        }
+        break;
+    }
 }
 
-void Renderer::setOverrideMaterial(Material *material) {
-    overrideMaterial = material;
+void RenderThread::enqueueJob(int jobType, void *data) {
+    Services()->getCore()->lockMutex(jobQueueMutex);
+    RendererThreadJob job;
+    job.jobType = jobType;
+    job.data = data;
+    jobQueue.push(job);
+    Services()->getCore()->unlockMutex(jobQueueMutex);
 }
 
-Number Renderer::getBackingResolutionScaleX() {
-    return backingResolutionScaleX;
+void RenderThread::setGraphicsInterface(Core *core, GraphicsInterface *interface) {
+    this->interface = interface;
+    this->core = core;
 }
 
-Number Renderer::getBackingResolutionScaleY() {
-    return backingResolutionScaleY;
+Renderer::Renderer() {
+    renderThread = new RenderThread();
+    Services()->getCore()->createThread(renderThread);
+    
+    cpuBufferIndex = 0;
+    gpuBufferIndex = 1;
 }
 
 Renderer::~Renderer() {
-}
-
-bool Renderer::Init() {
-	initOSSpecific();
-
-	return true;
-}
-
-void Renderer::pushVertexColor() {
-    vertexColorStack.push(currentVertexColor);
-}
-
-void Renderer::popVertexColor() {
-    currentVertexColor = vertexColorStack.top();
-    vertexColorStack.pop();
-}
-
-void Renderer::multiplyVertexColor(const Color &color) {
-    currentVertexColor = currentVertexColor * color;
-    setVertexColor(currentVertexColor.r, currentVertexColor.g, currentVertexColor.b, currentVertexColor.a);
-}
-
-void Renderer::loadVertexColorIdentity() {
-    currentVertexColor = Color(1.0, 1.0, 1.0, 1.0);
-    setVertexColor(currentVertexColor.r, currentVertexColor.g, currentVertexColor.b, currentVertexColor.a);
-}
-
-void Renderer::enableShaders(bool flag) {
-	shadersEnabled = flag;
-}
-
-void Renderer::setCameraMatrix(const Matrix4& matrix) {
-	cameraMatrix = matrix;
-}
-
-void Renderer::clearLights() {
-	numLights = 0;
-	numPointLights = 0;
-	numSpotLights = 0;	
-	lights.clear();
-	pointLights.clear();
-	spotLights.clear();
-}
-
-
-void Renderer::bindFrameBufferTexture(Texture *texture) {
-    framebufferStackColor.push(texture);
-}
-
-void Renderer::bindFrameBufferTextureDepth(Texture *texture) {
-    framebufferStackDepth.push(texture);
-}
-
-void Renderer::unbindFramebuffers() {
-    if(framebufferStackColor.size() > 0) {
-        framebufferStackColor.pop();
-    }
-    if(framebufferStackDepth.size() > 0) {
-        framebufferStackDepth.pop();
-    }
-
-    if(framebufferStackColor.size() > 0) {
-        Texture *rebindTexture = framebufferStackColor.top();
-        framebufferStackColor.pop();
-        bindFrameBufferTexture(rebindTexture);
-    }
-
-    if(framebufferStackDepth.size() > 0) {
-        Texture *rebindTexture = framebufferStackDepth.top();
-        framebufferStackDepth.pop();
-        bindFrameBufferTextureDepth(rebindTexture);
-    }
     
 }
 
-void Renderer::setExposureLevel(Number level) {
-	exposureLevel = level;
+void Renderer::setGraphicsInterface(Core *core, GraphicsInterface *interface) {
+    renderThread->setGraphicsInterface(core, interface);
 }
 
-void Renderer::addShaderModule(PolycodeShaderModule *module) {
-	shaderModules.push_back(module);
-}
-
-void Renderer::sortLights(){
-    sorter.basePosition = (getModelviewMatrix() * cameraMatrix).getPosition();
-	sort (pointLights.begin(), pointLights.end(), sorter);
-	sort (spotLights.begin(), spotLights.end(), sorter);	
-}
-
-void Renderer::addLight(int lightImportance, const Vector3 &position, const Vector3 &direction, int type, const Color &color, const Color &specularColor, Number constantAttenuation, Number linearAttenuation, Number quadraticAttenuation, Number intensity, Number spotlightCutoff, Number spotlightExponent, bool shadowsEnabled, Matrix4 *textureMatrix,Texture *shadowMapTexture) {
-
-	numLights++;
-	
-	LightInfo info;
-	if(textureMatrix != NULL) {
-		info.textureMatrix = *textureMatrix;
-	}
-	
-	info.lightImportance = lightImportance;
-	info.shadowMapTexture = shadowMapTexture;
-	info.shadowsEnabled = shadowsEnabled;
-	info.spotlightCutoff = spotlightCutoff;
-	info.spotlightExponent = spotlightExponent;	
-	info.intensity = intensity;
-	info.type = type;
-	info.dir = direction;
-	info.constantAttenuation = constantAttenuation;
-	info.linearAttenuation = linearAttenuation;
-	info.quadraticAttenuation = quadraticAttenuation;
-			
-	info.color.set(color.r, color.g, color.b);
-	info.specularColor = specularColor;
-	info.position = position;
-	lights.push_back(info);
-	switch(type) {
-		case 0: //point light
-			pointLights.push_back(info);
-			numPointLights++;
-		break;
-		case 1: //spot light
-			spotLights.push_back(info);			
-			numSpotLights++;
-		break;			
-	}
-}
-
-Number Renderer::getAnisotropyAmount() {
-	return anisotropy;
-}
-
-void Renderer::setAnisotropyAmount(Number amount) {
-	anisotropy = amount;
-}
-
-const Matrix4& Renderer::getCameraMatrix() const {
-	return cameraMatrix;
-}
-
-void Renderer::enableScissor(bool val) {
-	scissorEnabled = val;
-}
-
-void Renderer::setScissorBox(Polycode::Rectangle box) {
-	scissorBox = box;
-}
-
-Polycode::Rectangle Renderer::getScissorBox() {
-	return scissorBox;
-}
-
-void Renderer::setViewportShift(Number shiftX, Number shiftY) {
-	viewportShift.x = shiftX;
-	viewportShift.y = shiftY;
-	resetViewport();
-}
-
-bool Renderer::isScissorEnabled() {
-	return scissorEnabled;
-}
-
-void Renderer::billboardMatrixWithScale(Vector3 scale) {
-	Matrix4 matrix = getModelviewMatrix();
-	matrix.m[0][0] = 1.0f*scale.x;
-	matrix.m[0][1] = 0;
-	matrix.m[0][2] = 0;
-
-	matrix.m[1][0] = 0;
-	matrix.m[1][1] = 1.0f*scale.y;
-	matrix.m[1][2] = 0;
-
-	matrix.m[2][0] = 0;
-	matrix.m[2][1] = 0;
-	matrix.m[2][2] = 1.0f*scale.z;
-	
-	setModelviewMatrix(matrix);
-}
-
-void Renderer::billboardMatrix() {
-	Matrix4 matrix = getModelviewMatrix();
-	matrix.m[0][0] = 1;
-	matrix.m[0][1] = 0;
-	matrix.m[0][2] = 0;
-
-	matrix.m[1][0] = 0;
-	matrix.m[1][1] = 1;
-	matrix.m[1][2] = 0;
-
-	matrix.m[2][0] = 0;
-	matrix.m[2][1] = 0;
-	matrix.m[2][2] = 1;
-	setModelviewMatrix(matrix);
-}
-
-void *Renderer::getDataPointerForName(const String &name) {
-	if(name == "ambient_color") {
-		return (void*)&ambientColor;
-	}
-	return NULL;
-}
-
-void Renderer::setRendererShaderParams(Shader *shader, ShaderBinding *binding) {
-	for(int i=0; i < shader->expectedParams.size(); i++) {
-		void *dataPtr = getDataPointerForName(shader->expectedParams[i].name);
-		if(dataPtr) {
-			binding->addParamPointer(shader->expectedParams[i].type, shader->expectedParams[i].name, dataPtr);
-		}
-	}
-}
-
-void Renderer::applyMaterial(Material *material,  ShaderBinding *localOptions,unsigned int shaderIndex, bool forceMaterial) {
-    
-    if(overrideMaterial) {
-        if(!forceMaterial) {
-            material = overrideMaterial;
-        }
-    }
-    
-	if(!material->getShader(shaderIndex) || !shadersEnabled) {
-		setTexture(NULL);
-		return;
-	}
-	
-	FixedShaderBinding *fBinding;
-    
-    Shader *shader = material->getShader(shaderIndex);
-	if(shader->numPointLights + shader->numSpotLights > 0) {
-		sortLights();
-	}
-	
-	switch(material->getShader(shaderIndex)->getType()) {
-		case Shader::FIXED_SHADER:
-			fBinding = (FixedShaderBinding*)material->getShaderBinding(shaderIndex);
-			setTexture(fBinding->getDiffuseTexture());
-            break;
-		case Shader::MODULE_SHADER:
-			currentMaterial = material;
-			if(material->shaderModule == NULL) {
-				for(int m=0; m < shaderModules.size(); m++) {
-					PolycodeShaderModule *shaderModule = shaderModules[m];
-					if(shaderModule->hasShader(material->getShader(shaderIndex))) {
-						material->shaderModule = (void*)shaderModule;
-					}
-				}
-			} else {
-				PolycodeShaderModule *shaderModule = (PolycodeShaderModule*)material->shaderModule;
-				shaderModule->applyShaderMaterial(this, material, localOptions, shaderIndex);
-				currentShaderModule = shaderModule;
-			}
-            break;
-	}
-	
-	setBlendingMode(material->blendingMode);
-    setWireframePolygonMode(material->wireframe);
+RenderThread *Renderer::getRenderThread() {
+    return renderThread;
 }
 
 void Renderer::setBackingResolutionScale(Number xScale, Number yScale) {
@@ -370,42 +131,44 @@ void Renderer::setBackingResolutionScale(Number xScale, Number yScale) {
     backingResolutionScaleY = yScale;
 }
 
-int Renderer::getXRes() {
-	return xRes;
+Number Renderer::getBackingResolutionScaleX() {
+    return backingResolutionScaleX;
 }
 
-int Renderer::getYRes() {
-	return yRes;
+Number Renderer::getBackingResolutionScaleY() {
+    return backingResolutionScaleY;
 }
 
-void Renderer::setAmbientColor(Number r, Number g, Number b) {
-	ambientColor.setColor(r,g,b,1.0f);
+Number Renderer::getAnisotropyAmount() {
+    return anisotropy;
 }
 
-void Renderer::setClearColor(Number r, Number g, Number b, Number a) {
-	clearColor.setColor(r,g,b,a);	
+void Renderer::setAnisotropyAmount(Number amount) {
+    anisotropy = amount;
 }
 
-void Renderer::setClearColor(Color color) {
-	setClearColor(color.r, color.g, color.b, color.a);
+Cubemap *Renderer::createCubemap(Texture *t0, Texture *t1, Texture *t2, Texture *t3, Texture *t4, Texture *t5) {
+    return NULL;
 }
 
-void Renderer::setTextureFilteringMode(int mode) {
-	textureFilteringMode = mode;
+void Renderer::processDrawBuffer(GPUDrawBuffer *buffer) {
+    renderThread->enqueueJob(RenderThread::JOB_PROCESS_DRAW_BUFFER, buffer);
 }
 
-void Renderer::setViewportSize(int w, int h) {
-	viewportWidth = w;
-	viewportHeight = h;
-	resetViewport();
+void Renderer::flushContext() {
+    renderThread->enqueueJob(RenderThread::JOB_FLUSH_CONTEXT, NULL);
 }
 
-Number Renderer::getViewportWidth() {
-	return viewportWidth;
+Texture *Renderer::createTexture(unsigned int width, unsigned int height, char *textureData, bool clamp, bool createMipmaps, int type) {
+    Texture *texture = new Texture(width, height, textureData, clamp, createMipmaps, type);
+    renderThread->enqueueJob(RenderThread::JOB_CREATE_TEXTURE, (void*)texture);
+    return texture;
 }
 
-Number Renderer::getViewportHeight() {
-	return viewportHeight;
+void Renderer::destroyTexture(Texture *texture) {
+    
+}
+void createRenderTextures(Texture **colorBuffer, Texture **depthBuffer, int width, int height, bool floatingPointBuffer) {
+    
 }
-
 

Core/Contents/Source/PolyResourceManager.cpp

@@ -24,7 +24,6 @@
 #include "PolyCoreServices.h"
 #include "PolyCubemap.h"
 #include "PolyMaterialManager.h"
-#include "PolyModule.h"
 #include "PolyFontManager.h"
 #include "PolyLogger.h"
 #include "PolyMaterial.h"

Core/Contents/Source/PolyScene.cpp

@@ -52,9 +52,7 @@ void Scene::initScene(int sceneType, bool virtualScene) {
 	core = CoreServices::getInstance()->getCore();
 	this->sceneType = sceneType;
 	defaultCamera = new Camera(this);
-	activeCamera = defaultCamera;	
-	fogEnabled = false;
-	fogMode = Renderer::FOG_LINEAR;
+	activeCamera = defaultCamera;
     overrideMaterial = NULL;
 	lightingEnabled = false;
 	enabled = true;
@@ -152,7 +150,9 @@ Scene::~Scene() {
 
 void Scene::enableLighting(bool enable) {
 	lightingEnabled = enable;
-	CoreServices::getInstance()->getRenderer()->enableLighting(enable);
+
+    // RENDERER_TODO
+//	CoreServices::getInstance()->getRenderer()->enableLighting(enable);
 }
 
 void Scene::enableFog(bool enable) {
@@ -215,14 +215,19 @@ void Scene::setEntityVisibility(Entity *entity, Camera *camera) {
     }
 }
 
-void Scene::Render(Camera *targetCamera) {	
-	if(!targetCamera && !activeCamera)
-		return;
+void Scene::Render(Camera *targetCamera) {
+    if(!targetCamera && !activeCamera)
+        return;
+    if(!targetCamera)
+        targetCamera = activeCamera;
+    
+    GPUDrawBuffer *drawBuffer = new GPUDrawBuffer();
     
-    renderer->setOverrideMaterial(overrideMaterial);
+    drawBuffer->viewport = targetCamera->getViewport();
+///    drawBuffer->projectionMatrix = targetCamera->
+
+   // renderer->setOverrideMaterial(overrideMaterial);
 	
-	if(!targetCamera)
-		targetCamera = activeCamera;
 		
 	//make these the closest
 	
@@ -231,17 +236,14 @@ void Scene::Render(Camera *targetCamera) {
 	
 	
 	targetCamera->rebuildTransformMatrix();
-		
+    drawBuffer->projectionMatrix = targetCamera->getProjectionMatrix();
+    
+/*
 	if(useClearColor) {
 		CoreServices::getInstance()->getRenderer()->setClearColor(clearColor.r,clearColor.g,clearColor.b, clearColor.a);	
 	}
-	if (useClearColor || useClearDepth) {
-		CoreServices::getInstance()->getRenderer()->clearScreen(useClearColor, useClearDepth);
-	}
-	
-	CoreServices::getInstance()->getRenderer()->setAmbientColor(ambientColor.r,ambientColor.g,ambientColor.b);		
-	
-	CoreServices::getInstance()->getRenderer()->clearLights();
+	CoreServices::getInstance()->getRenderer()->setAmbientColor(ambientColor.r,ambientColor.g,ambientColor.b);
+*/
 	
 	for(int i=0; i < lights.size(); i++) {
 		SceneLight *light = lights[i];
@@ -261,8 +263,6 @@ void Scene::Render(Camera *targetCamera) {
 		Texture *shadowMapTexture = NULL;
 		if(light->areShadowsEnabled()) {
 			if(light->getType() == SceneLight::SPOT_LIGHT) {
-//				textureMatrix.identity();
-				
 				Matrix4 matTexAdj(0.5f,	0.0f,	0.0f,	0.0f,
 								  0.0f,	0.5f,	0.0f,	0.0f,
 								  0.0f,	0.0f,	0.5f,	0.0f,
@@ -270,8 +270,7 @@ void Scene::Render(Camera *targetCamera) {
 				
 				light->renderDepthMap(this);
 				textureMatrix = light->getLightViewMatrix() * matTexAdj;				
-				matrixPtr = &textureMatrix;				
-			//	CoreServices::getInstance()->getRenderer()->addShadowMap(light->getZBufferTexture());
+				matrixPtr = &textureMatrix;
 				shadowMapTexture = light->getZBufferTexture();
 			}
 		}
@@ -280,28 +279,26 @@ void Scene::Render(Camera *targetCamera) {
 		if(light->getParentEntity() != NULL) {
 			position = light->getParentEntity()->getConcatenatedMatrix() * position;			
 		}
-		CoreServices::getInstance()->getRenderer()->addLight(light->getLightImportance(), position, direction, light->getLightType(), light->lightColor, light->specularLightColor, light->getConstantAttenuation(), light->getLinearAttenuation(), light->getQuadraticAttenuation(), light->getIntensity(), light->getSpotlightCutoff(), light->getSpotlightExponent(), light->areShadowsEnabled(), matrixPtr, shadowMapTexture);
+        
+		//CoreServices::getInstance()->getRenderer()->addLight(light->getLightImportance(), position, direction, light->getLightType(), light->lightColor, light->specularLightColor, light->getConstantAttenuation(), light->getLinearAttenuation(), light->getQuadraticAttenuation(), light->getIntensity(), light->getSpotlightCutoff(), light->getSpotlightExponent(), light->areShadowsEnabled(), matrixPtr, shadowMapTexture);
 	}	
 		
-	targetCamera->doCameraTransform();
-    
-	CoreServices::getInstance()->getRenderer()->enableFog(fogEnabled);
-	if(fogEnabled) {
-		CoreServices::getInstance()->getRenderer()->setFogProperties(fogMode, fogColor, fogDensity, fogStartDepth, fogEndDepth);
-	} else {
-		CoreServices::getInstance()->getRenderer()->setFogProperties(fogMode, fogColor, 0.0, fogStartDepth, fogEndDepth);	
-	}
-	
+    	
     if(_doVisibilityChecking) {
         targetCamera->buildFrustumPlanes();
         setEntityVisibility(&rootEntity, targetCamera);
     }
-	rootEntity.transformAndRender();		
+	rootEntity.transformAndRender(drawBuffer);
+
+    
+    renderer->processDrawBuffer(drawBuffer);
+    
 }
 
 
 void Scene::RenderDepthOnly(Camera *targetCamera) {
-	
+    // RENDERER_TODO
+    /*
 	CoreServices::getInstance()->getRenderer()->cullFrontFaces(true);
 
 	targetCamera->rebuildTransformMatrix();	
@@ -318,10 +315,13 @@ void Scene::RenderDepthOnly(Camera *targetCamera) {
 	
 	CoreServices::getInstance()->getRenderer()->enableShaders(true);
 	CoreServices::getInstance()->getRenderer()->cullFrontFaces(false);	
+     */
 }
 
 Ray Scene::projectRayFromCameraAndViewportCoordinate(Camera *camera, Vector2 coordinate) {
 
+        // RENDERER_TODO
+    /*
 	Polycode::Rectangle viewport = camera->getViewport();
     
     if(remapMouse) {
@@ -375,7 +375,9 @@ Ray Scene::projectRayFromCameraAndViewportCoordinate(Camera *camera, Vector2 coo
 		break;		
 	}
 
+
 	return Ray(pos, dir);
+*/     
 }
 
 

Core/Contents/Source/PolySceneEntityInstance.cpp

@@ -449,7 +449,8 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
                 if(fileName) {
                     SceneMesh *newMesh = new SceneMesh(fileName->stringVal);
                     applySceneMesh(meshEntry, newMesh);
-                    newMesh->cacheToVertexBuffer(true);
+                    // RENDERER_TODO
+                    //newMesh->cacheToVertexBuffer(true);
                     entity = newMesh;
                 }
             }

Core/Contents/Source/PolySceneLabel.cpp

@@ -119,16 +119,20 @@ void SceneLabel::updateFromLabel() {
 	
     setLocalBoundingBox(label->getWidth()*labelScale / CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleX(), label->getHeight()*labelScale/ CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleX(), 0.001);
     
+        // RENDERER_TODO
+    /*
 	if(useVertexBuffer)
 		CoreServices::getInstance()->getRenderer()->createVertexBufferForMesh(mesh);
+     */
 	
 }
 
-void SceneLabel::Render() {
+void SceneLabel::Render(GPUDrawBuffer *buffer) {
 	if(positionAtBaseline) {
-		CoreServices::getInstance()->getRenderer()->translate2D(0.0, (((Number)label->getSize()*labelScale) * -1.0 / CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleY()) + (((Number)label->getBaselineAdjust())*labelScale/CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleY()));
+        // RENDERER_TODO
+		//CoreServices::getInstance()->getRenderer()->translate2D(0.0, (((Number)label->getSize()*labelScale) * -1.0 / CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleY()) + (((Number)label->getBaselineAdjust())*labelScale/CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleY()));
 	}
-	ScenePrimitive::Render();
+	ScenePrimitive::Render(buffer);
 }
 
 int SceneLabel::getTextWidthForString(String text) {

Core/Contents/Source/PolySceneLight.cpp

@@ -70,6 +70,8 @@ int SceneLight::getLightImportance() const {
 }
 
 void SceneLight::enableShadows(bool val, unsigned int resolution) {
+        // RENDERER_TODO
+    /*
 	if(val) {
         if(zBufferTexture) {
             CoreServices::getInstance()->getMaterialManager()->deleteTexture(zBufferTexture);
@@ -77,10 +79,6 @@ void SceneLight::enableShadows(bool val, unsigned int resolution) {
         CoreServices::getInstance()->getRenderer()->createRenderTextures(NULL, &zBufferTexture, resolution, resolution, false);
 		if(!spotCamera) {
 			spotCamera = new Camera(parentScene);
-            /*
-            spotCamera->setProjectionMode(Camera::ORTHO_SIZE_MANUAL);
-            spotCamera->setOrthoSize(5.0, 5.0);
-             */
             spotCamera->editorOnly = true;
             spotCamera->setClippingPlanes(0.01, 100.0);
 //            spotCamera->setPitch(90.0);
@@ -91,6 +89,7 @@ void SceneLight::enableShadows(bool val, unsigned int resolution) {
 	} else {
 		shadowsEnabled = false;
 	}
+*/
 }
 
 bool SceneLight::areShadowsEnabled() const {
@@ -128,6 +127,8 @@ unsigned int SceneLight::getShadowMapResolution() const {
 }
 
 void SceneLight::renderDepthMap(Scene *scene) {
+        // RENDERER_TODO
+    /*
     spotCamera->setFOV(shadowMapFOV);
 	Renderer* renderer = CoreServices::getInstance()->getRenderer();
 	renderer->pushMatrix();
@@ -145,6 +146,7 @@ void SceneLight::renderDepthMap(Scene *scene) {
 	renderer->unbindFramebuffers();
 	renderer->popMatrix();
 	renderer->setViewportSize(vpW , vpH);
+     */
 }
 
 Entity *SceneLight::Clone(bool deepClone, bool ignoreEditorOnly) const {

Core/Contents/Source/PolySceneManager.cpp

@@ -74,6 +74,10 @@ void SceneManager::setRenderer(Renderer *renderer) {
 }
 
 void SceneManager::renderVirtual() {
+    
+        // RENDERER_TODO
+    /*
+    
 	bool anyVirtualsRendered = false;
 	for(int i=0;i<renderTextures.size();i++) {
 		if(renderTextures[i]->enabled) {
@@ -85,21 +89,22 @@ void SceneManager::renderVirtual() {
 	if (anyVirtualsRendered) {
 		renderer->clearScreen();
 	}
+     */
 }
 
-void SceneManager::Render() {
+void SceneManager::Render(const Polycode::Rectangle &viewport) {    
 	for(int i=0;i<scenes.size();i++) {
 		if(scenes[i]->isEnabled() && !scenes[i]->isVirtual()) {
-			renderer->loadIdentity();
 			Scene *scene = scenes[i];
 			if(scene->getActiveCamera()->hasFilterShader()) {
 				scene->getActiveCamera()->drawFilter();
 			} else {
+                scene->getActiveCamera()->setViewport(viewport);
 				scene->Render();
 			}
 		}
-		renderer->loadIdentity();			
 	}
+
 }
 
 void SceneManager::fixedUpdate() {

Core/Contents/Source/PolySceneMesh.cpp

@@ -135,10 +135,6 @@ void SceneMesh::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly)
     Mesh *newMesh = mesh->Copy();
     _clone->setMesh(newMesh);
     
-    if(useVertexBuffer) {
-        _clone->cacheToVertexBuffer(true);
-    }
-    
     _clone->setMaterial(material);
     if(material) {
         localShaderOptions->copyTo(_clone->getLocalShaderOptions());
@@ -252,6 +248,7 @@ Skeleton *SceneMesh::getSkeleton() {
 }
 
 void SceneMesh::renderMeshLocally() {
+    /*
 	Renderer *renderer = CoreServices::getInstance()->getRenderer();
 
 	
@@ -317,14 +314,7 @@ void SceneMesh::renderMeshLocally() {
     } else {
         renderer->drawArrays(mesh->getMeshType(), NULL);
     }
-}
-
-void SceneMesh::cacheToVertexBuffer(bool cache) {
-
-	if(cache && !mesh->hasVertexBuffer()) {
-		CoreServices::getInstance()->getRenderer()->createVertexBufferForMesh(mesh);
-	}
-	useVertexBuffer = cache;
+     */
 }
 
 bool SceneMesh::customHitDetection(const Ray &ray) {
@@ -359,19 +349,20 @@ bool SceneMesh::customHitDetection(const Ray &ray) {
 	return false;
 }
 
-void SceneMesh::Render() {
-	
-	Renderer *renderer = CoreServices::getInstance()->getRenderer();
-	
-    renderer->enableAlphaTest(alphaTest);
-	renderer->enableBackfaceCulling(backfaceCulled);
+void SceneMesh::Render(GPUDrawBuffer *buffer) {
     
-	renderer->setLineSize(lineWidth);
-	renderer->setLineSmooth(lineSmooth);
-	renderer->setPointSize(pointSize);
-	renderer->setPointSmooth(pointSmooth);
-	
-	if(material) {
+    drawCall.options.alphaTest = alphaTest;
+    drawCall.options.linePointSize = lineWidth;
+    drawCall.options.backfaceCull = backfaceCulled;
+    drawCall.options.depthTest = depthTest;
+    drawCall.options.depthWrite = depthWrite;
+    drawCall.ownsAttributes = false;
+    
+    drawCall.attributeArrays.push_back(&mesh->vertexPositionArray);
+    drawCall.numVertices = mesh->getVertexCount();
+    
+    /*
+   	if(material) {
         
 		renderer->applyMaterial(material, localShaderOptions,0, forceMaterial);
 	} else {
@@ -429,4 +420,5 @@ void SceneMesh::Render() {
 		renderer->enableDepthTest(depthTestVal);
 	}	
     renderer->setWireframePolygonMode(false);    
+     */
 }

Core/Contents/Source/PolySceneRenderTexture.cpp

@@ -72,6 +72,9 @@ Camera *SceneRenderTexture::getTargetCamera() {
 }
 
 void SceneRenderTexture::Render() {
+    
+    // RENDERER_TODO
+    /*
     renderer->setViewportSize(targetTexture->getWidth(), targetTexture->getHeight());
     renderer->loadIdentity();
     if(targetCamera->hasFilterShader()) {
@@ -82,10 +85,13 @@ void SceneRenderTexture::Render() {
         renderer->unbindFramebuffers();
     }
     renderer->loadIdentity();
+     */
 }
 
 Image *SceneRenderTexture::saveToImage() {
-    return renderer->renderBufferToImage(targetTexture);
+    //RENDERER_TODO
+    //return renderer->renderBufferToImage(targetTexture);
+    return NULL;
 }
 
 Texture *SceneRenderTexture::getTargetTexture() {

Core/Contents/Source/PolySceneSprite.cpp

@@ -249,7 +249,7 @@ unsigned int SceneSprite::getCurrentFrame() {
     return currentFrame;
 }
 
-void SceneSprite::Render() {
+void SceneSprite::Render(GPUDrawBuffer *buffer) {
     
     if(!currentSprite || !currentSpriteState) {
         return;
@@ -264,7 +264,7 @@ void SceneSprite::Render() {
         useVertexBuffer = false;
     }
     
-    SceneMesh::Render();
+    SceneMesh::Render(buffer);
 }
 
 SceneSprite::~SceneSprite() {

Core/Contents/Source/PolyTexture.cpp

@@ -31,7 +31,8 @@ Texture::Texture(unsigned int width, unsigned int height, char *textureData,bool
 	this->height = height;
 	this->clamp = clamp;
 	this->createMipmaps = createMipmaps;
-	
+    this->type = type;
+    
 	switch(type) {
 		case Image::IMAGE_RGB:
 			pixelSize = 3;			
@@ -56,12 +57,13 @@ Texture::Texture(unsigned int width, unsigned int height, char *textureData,bool
 	scrollSpeedY = 0;
 	scrollOffsetX = 0;
 	scrollOffsetY = 0;
+    
+    platformData = NULL;
 }
 
 void Texture::reloadResource() {
 	Image *image = new Image(getResourcePath());
 	setImageData(image);
-	recreateFromImageData();
 	delete image;
 	Resource::reloadResource();	
 }
@@ -102,7 +104,6 @@ void Texture::setImageData(Image *data) {
 		free(this->textureData);
 	this->textureData = (char*)malloc(width*height*pixelSize);
 	memcpy(this->textureData, data->getPixels(), width*height*pixelSize);
-//	setTextureData(data->getPixels());
 
 }
 
@@ -112,17 +113,3 @@ Texture::Texture(Image *image) : Resource(Resource::RESOURCE_TEXTURE) {
 	memcpy(this->textureData, image->getPixels(), image->getWidth()*image->getHeight()*pixelSize);	
 
 }
-
-void Texture::updateScroll(int elapsed) {
-	Number ef = ((Number)(elapsed))/1000.0f;
-	scrollOffsetX += scrollSpeedX*ef;
-	scrollOffsetY += scrollSpeedY*ef;
-}
-
-Number Texture::getScrollOffsetX() const {
-	return scrollOffsetX;
-}
-
-Number Texture::getScrollOffsetY() const {
-	return scrollOffsetY;
-}

Modules/Contents/TUIO/Include/TUIOInputModule.h

@@ -3,7 +3,6 @@
 
 #include <PolyInputEvent.h>
 #include <PolyCore.h>
-#include <PolyModule.h>
 
 #include "TuioListener.h"
 #include "TuioClient.h"
@@ -21,7 +20,7 @@ class TUIOEvent {
 		TouchInfo touch;
 };
 
-class TUIOInputModule : public PolycodeModule, TuioListener {
+class TUIOInputModule : public TuioListener {
 	public:
 		TUIOInputModule(int port);
 		virtual ~TUIOInputModule();

Modules/Contents/TUIO/Source/TUIOInputModule.cpp

@@ -3,13 +3,12 @@
 #include <Polycode.h>
 
 
-TUIOInputModule::TUIOInputModule(int port) : PolycodeModule(), TuioListener() {
+TUIOInputModule::TUIOInputModule(int port) : TuioListener() {
 	tuioClient = new TuioClient(port);
 	tuioClient->addTuioListener(this);
 	tuioClient->connect();
 	
 	eventMutex = CoreServices::getInstance()->getCore()->createMutex();
-	_requiresUpdate = true;
 
 }
 

Modules/Contents/UI/Source/PolyUIElement.cpp

@@ -266,6 +266,9 @@ Texture *UIRect::getTexture() {
 }
 
 void UIRect::Render() {
+    
+    // RENDERER_TODO
+    /*
 	renderer->clearShader();
 	renderer->setTexture(texture);
     
@@ -273,6 +276,7 @@ void UIRect::Render() {
     renderer->pushRenderDataArray(&rectMesh->vertexTexCoordArray);
 
 	renderer->drawArrays(Mesh::QUAD_MESH, NULL);
+     */
 }
 
 void UIRect::Resize(Number width, Number height) {