Started restoring screen shader functionality in new renderer

assets/default/default/Invert.frag

@@ -0,0 +1,6 @@
+uniform sampler2D screenColorBuffer;
+varying vec2 texCoordVar;
+void main()
+{
+    gl_FragColor = vec4(1.0-texture2D( screenColorBuffer, texCoordVar).xyz, 1.0);
+}

assets/default/default/ScreenShader.vert

@@ -0,0 +1,13 @@
+#ifdef GLES2
+	precision mediump float;
+#endif
+
+attribute vec4 position;
+attribute vec2 texCoord;
+varying vec2 texCoordVar;
+
+void main()
+{
+    gl_Position =  position;
+    texCoordVar = texCoord;
+}

assets/default/default/default.mat

@@ -32,9 +32,20 @@
 		<shader type="glsl" name="UnlitWireframe" numPointLights="0" numSpotLights="0">		
 			<vp source="default/UnlitUntextured.vert"/>
 			<fp source="default/UnlitWireframe.frag"/>
-		</shader>	
+		</shader>
+		<shader type="glsl" name="InvertShader" screen="true">		
+			<vp source="default/ScreenShader.vert"/>
+			<fp source="default/Invert.frag"/>
+		</shader>		
 	</shaders>	
-	<materials>	
+	<materials>
+		<material name="Invert">
+			<shader name="InvertShader">
+				<targettextures>			
+					<targettexture mode="color" name="screenColorBuffer"/>				
+				</targettextures>				
+			</shader>
+		</material>		
 		<material name="Default">
 			<shader name="DefaultUntexturedShader">
 			</shader>

build/osx/TemplateApp/TemplateApp/PolycodeTemplateApp.mm

@@ -16,7 +16,6 @@ PolycodeTemplateApp::PolycodeTemplateApp(PolycodeView *view) {
     
     Scene *scene = new Scene(Scene::SCENE_2D);
     scene->useClearColor = true;
-   
     
     ScenePrimitive *test = new ScenePrimitive(ScenePrimitive::TYPE_VPLANE, 10.0, 10.0);
     test->setMaterialByName("UnlitUntextured");
@@ -25,8 +24,9 @@ PolycodeTemplateApp::PolycodeTemplateApp(PolycodeView *view) {
     test->scissorBox.setRect(100, 50, 100, 30);
     scene->addChild(test);
     
-    Sound *music = new Sound("BUGSHUFFLE.ogg");
-    music->Play();
+    scene->getDefaultCamera()->setPostFilterByName("Invert");
+//    Sound *music = new Sound("BUGSHUFFLE.ogg");
+  //  music->Play();
     
     Services()->getInput()->addEventListener(this, InputEvent::EVENT_KEYDOWN);
 }

include/polycode/core/PolyCamera.h

@@ -33,6 +33,7 @@ namespace Polycode {
 	class Material;
 	class ShaderBinding;
 	class Texture;
+    class GPUDrawCall;
 
 	/**
 	* Camera in a 3D scene. Cameras can be added to a scene and changed between dynamically. You can also set a shader to a camera that will run as a screen shader for post-processing effects.
@@ -188,7 +189,7 @@ namespace Polycode {
             /**
              * Binds target buffers and renders the scene in multiple passes based on the post filter material.
              */
-			void drawFilter(Texture *targetTexture = NULL, Number targetTextureWidth = 0.0, Number targetTextureHeight = 0.0, Texture *targetColorTexture = NULL, Texture *targetZTexture = NULL);
+			void drawFilter(RenderBuffer *targetBuffer);
 			
 			/**
 			* Sets the exposure for the camera. The exposure value is passed automatically to  post material shaders using an "exposure" uniform.
@@ -210,7 +211,7 @@ namespace Polycode {
 			* Sets the post-processing shader for the camera.
 			* @param shaderMaterial Post processing shader material.
 			*/
-			void setPostFilter(Material *shaderMaterial);
+			void setPostFilter(Material *material);
 			
 			/**
 			* Sets the post-processing shader for the camera by name. The material needs have been added as a resource.
@@ -223,24 +224,6 @@ namespace Polycode {
 			*/
 			void removePostFilter();
 			
-			/**
-			* Returns the local shader options for the camera post processing material.
-			*/
-			std::vector<ShaderBinding*> getLocalShaderOptions() { return localShaderOptions; }
-			
-            /**
-             * Returns the number of local material shader options.
-             * @return Number of local material shader options.
-             */
-            unsigned int getNumLocalShaderOptions() const;
-        
-            /**
-             * Returns the shader option binding at the specified shader index.
-             * @param Specified shader index.
-             * @return Shader binding at specified shader index or NULL if index is out of bounds.
-             */
-            ShaderBinding* getLocalShaderOption(unsigned int index) const;
-        
 			/**
 			* Returns the shader material applied to the camera.
 			*/			
@@ -309,23 +292,24 @@ namespace Polycode {
              */
 			int getProjectionMode() const { return projectionMode; }
 
-            void setUseGlobalFramebuffer(bool val);
-            bool getUseGlobalFramebuffer() const;
-        
             Vector3 projectRayFrom2DCoordinate(const Vector2 &coordinate, const Polycode::Rectangle &viewport);
 
+            void renderFullScreenQuad(GPUDrawBuffer *drawBuffer, int shaderPass);
+        
 		protected:
+        
+            Mesh *screenQuadMesh;
 
             void setOrthoMatrix(Matrix4 &matrix, Number xSize, Number ySize, Number _near, Number _far, bool centered);
         
-            bool useGlobalFramebuffer;
-			int projectionMode;
-        
+			int projectionMode;        
 			Matrix4 projectionMatrix;
 
 			Polycode::Rectangle viewport;
 			Number orthoSizeX;
 			Number orthoSizeY;
+        
+            std::vector<ShaderPass> shaderPasses;
 
 			Number nearClipPlane;
 			Number farClipPlane;
@@ -340,9 +324,8 @@ namespace Polycode {
 			Scene *parentScene;
 
 			Material *filterShaderMaterial;			
-			Texture *originalSceneTexture;			
-			Texture *zBufferSceneTexture;
-			std::vector<ShaderBinding*> localShaderOptions;
+            RenderBuffer *originalFramebuffer;
+        
 			bool _hasFilterShader;
 	};	
 }

include/polycode/core/PolyShader.h

@@ -37,7 +37,8 @@ namespace Polycode {
 	class Texture;
     class VertexDataArray;
     class LocalShaderParam;
-	
+    class RenderBuffer;
+    
 	class _PolyExport ProgramParam {
 		public:
 	
@@ -134,7 +135,7 @@ namespace Polycode {
 			Number width;
 			Number height;
 			int sizeMode;
-			Texture *texture;			
+			RenderBuffer *buffer;
 			
 			Number normalizedWidth;
 			Number normalizedHeight;
@@ -192,7 +193,7 @@ namespace Polycode {
 			String id;
 			String name;
 			int mode;
-			Texture *texture;
+			RenderBuffer *buffer;
 			static const int MODE_IN = 0;
 			static const int MODE_OUT = 1;
 			static const int MODE_COLOR = 2;

src/core/PolyCamera.cpp

@@ -30,6 +30,7 @@
 #include "polycode/core/PolyScene.h"
 #include "polycode/core/PolyShader.h"
 #include "polycode/core/PolyTexture.h"
+#include "polycode/core/PolyGPUDrawBuffer.h"
 
 using namespace Polycode;
 			
@@ -39,34 +40,24 @@ Camera::Camera(Scene *parentScene) : Entity() {
 	setParentScene(parentScene);
 	setFOV(45.0f);
 	filterShaderMaterial = NULL;
-	originalSceneTexture = NULL;
-	zBufferSceneTexture = NULL;
+	originalFramebuffer = NULL;
 	exposureLevel = 1.0f;
 	_hasFilterShader = false;
 	frustumCulling = true;
 	nearClipPlane = 1.0;
 	farClipPlane = 1000.0;
 	topLeftOrtho = false;
+    screenQuadMesh = NULL;
     orthoSizeX = 1.0;
 	orthoSizeY = 1.0;
-    useGlobalFramebuffer = false;
 }
 
 Camera::~Camera() {	
-	for(int i=0; i < localShaderOptions.size(); i++) {
-		delete localShaderOptions[i];
-	}
-
-	delete originalSceneTexture;
-	delete zBufferSceneTexture;
-}
-
-void Camera::setUseGlobalFramebuffer(bool val) {
-    useGlobalFramebuffer = val;
-}
-
-bool Camera::getUseGlobalFramebuffer() const {
-    return useGlobalFramebuffer;
+    for(int i=0; i < shaderPasses.size(); i++)  {
+        delete shaderPasses[i].shaderBinding;
+    }
+    delete screenQuadMesh;
+    Services()->getRenderer()->destroyRenderBuffer(originalFramebuffer);
 }
 
 void Camera::setClippingPlanes(Number nearClipPlane, Number farClipPlane) {
@@ -145,18 +136,6 @@ Number Camera::getOrthoSizeY() {
 	return orthoSizeY;
 }
 
-unsigned int Camera::getNumLocalShaderOptions()const {
-    return localShaderOptions.size();
-}
-
-ShaderBinding* Camera::getLocalShaderOption(unsigned int index) const {
-    if(index < localShaderOptions.size()) {
-        return localShaderOptions[index];
-    } else {
-        return NULL;
-    }
-}
-
 void Camera::buildFrustumPlanes() {
 
 	Matrix4 mv;
@@ -332,8 +311,9 @@ void Camera::setParentScene(Scene *parentScene) {
 
 void Camera::setPostFilterByName(const String& materialName) {
 	Material *shaderMaterial = (Material*) CoreServices::getInstance()->getResourceManager()->getGlobalPool()->getResource(Resource::RESOURCE_MATERIAL, materialName);
-	if(shaderMaterial)
-		setPostFilter(shaderMaterial);		
+    if(shaderMaterial) {
+        setPostFilter(shaderMaterial);
+    }
 }
 
 void Camera::removePostFilter() {
@@ -343,135 +323,123 @@ void Camera::removePostFilter() {
 	}
 }
 
-void Camera::setPostFilter(Material *shaderMaterial) {
+void Camera::setPostFilter(Material *material) {
+    if(!material) {
+        return;
+    }
     
-    // RENDERER_TODO
-    /*
-	if(!shaderMaterial)
-		return;
-	if(shaderMaterial->getNumShaders() == 0)
-		return;
-		
-	this->filterShaderMaterial = shaderMaterial;
-	if(!originalSceneTexture) {
-        CoreServices::getInstance()->getRenderer()->createRenderTextures(&originalSceneTexture, &zBufferSceneTexture, CoreServices::getInstance()->getCore()->getXRes(), CoreServices::getInstance()->getCore()->getYRes(), shaderMaterial->fp16RenderTargets);
-	}
-	
-	for(int i=0; i < shaderMaterial->getNumShaders(); i++) {
-		ShaderBinding* binding = shaderMaterial->getShader(i)->createBinding();		
-		localShaderOptions.push_back(binding);
-		binding->addParamPointer(ProgramParam::PARAM_NUMBER, "exposure", (void*)&exposureLevel);
-	}
+    if(material->getNumShaderPasses() == 0) {
+        return;
+    }
+    this->filterShaderMaterial = material;
 
-	_hasFilterShader = true;
-     */
+    if(!originalFramebuffer) {
+        originalFramebuffer = Services()->getRenderer()->createRenderBuffer(CoreServices::getInstance()->getCore()->getXRes(), CoreServices::getInstance()->getCore()->getYRes(), true);
+    }
+    
+    for(int i=0; i < material->getNumShaderPasses(); i++)  {
+        ShaderPass shaderPass = material->getShaderPass(i);
+        shaderPass.shaderBinding = new ShaderBinding();
+        shaderPass.shaderBinding->targetShader = shaderPass.shader;
+        shaderPass.shaderBinding->resetAttributes = true;
+        shaderPasses.push_back(shaderPass);
+    }
+    
+    _hasFilterShader = true;
 }
 
 bool Camera::hasFilterShader() {
 	return _hasFilterShader;
 }
 
-void Camera::drawFilter(Texture *targetTexture, Number targetTextureWidth, Number targetTextureHeight, Texture *targetColorTexture, Texture *targetZTexture) {
+void Camera::renderFullScreenQuad(GPUDrawBuffer *drawBuffer, int shaderPass) {
+    GPUDrawCall drawCall;
+    
+    if(!screenQuadMesh) {
+        screenQuadMesh = new Mesh(Mesh::TRI_MESH);
+        
+        screenQuadMesh->addVertexWithUV(1.0, 1.0, 0.0, 1.0, 1.0);
+        screenQuadMesh->addVertexWithUV(1.0, -1.0, 0.0, 1.0, 0.0);
+        screenQuadMesh->addVertexWithUV(-1.0, -1.0, 0.0, 0.0, 0.0);
+        
+        screenQuadMesh->addVertexWithUV(-1.0, -1.0, 0.0, 0.0, 0.0);
+        screenQuadMesh->addVertexWithUV(-1.0, 1.0, 0.0, 0.0, 1.0);
+        screenQuadMesh->addVertexWithUV(1.0, 1.0, 0.0, 1.0, 1.0);
+    }
+    
+    drawCall.options.alphaTest = false;
+    drawCall.options.backfaceCull = true;
+    drawCall.options.depthTest = false;
+    drawCall.options.depthWrite = false;
+    drawCall.mesh = screenQuadMesh;
+    drawCall.material = filterShaderMaterial;
+    drawCall.shaderPasses.push_back(shaderPasses[shaderPass]);
+    
+    drawBuffer->drawCalls.push_back(drawCall);
+}
 
-    // RENDERER_TODO
-/*
+void Camera::drawFilter(RenderBuffer *targetBuffer) {
 	if(!filterShaderMaterial)
 		return;
+
+    RenderBuffer *finalTargetBuffer = NULL;
 		
-	Texture *finalTargetColorTexture = NULL;
-	Texture *finalTargetZTexture = NULL;
-		
-	if(targetTexture) {	
-		finalTargetColorTexture = targetColorTexture;
-		finalTargetZTexture = targetZTexture;		
-		renderer->setViewportSize(targetTextureWidth, targetTextureHeight);		
+	if(targetBuffer) {
+        finalTargetBuffer = targetBuffer;
+        Polycode::Rectangle newVP(0.0, 0.0, targetBuffer->getWidth(), targetBuffer->getHeight());
+        setViewport(newVP);
 	} else {
-        if(!useGlobalFramebuffer) {
-            finalTargetColorTexture = originalSceneTexture;
-            finalTargetZTexture = zBufferSceneTexture;
-        }
-        renderer->setViewportSize(renderer->getXRes(), renderer->getYRes());
+        finalTargetBuffer = originalFramebuffer;
 	}
-    
-    if(finalTargetColorTexture) {
-        renderer->bindFrameBufferTexture(finalTargetColorTexture);
-    }
-    if(finalTargetZTexture) {
-        renderer->bindFrameBufferTextureDepth(finalTargetZTexture);
-    }
-	parentScene->Render(this);
-    
-    if(finalTargetColorTexture && finalTargetZTexture) {
-        renderer->unbindFramebuffers();
-    }
-
 
+    parentScene->Render(this, finalTargetBuffer, NULL, true);
+    
 	ShaderBinding* materialBinding;
-	for(int i=0; i < filterShaderMaterial->getNumShaders(); i++) {
-		materialBinding = filterShaderMaterial->getShaderBinding(i);
-		
+	for(int i=0; i < filterShaderMaterial->getNumShaderPasses(); i++) {
+        
+        materialBinding = filterShaderMaterial->getShaderPass(i).shaderBinding;
+        
 		for(int j=0; j < materialBinding->getNumColorTargetBindings(); j++) {
 			RenderTargetBinding *colorBinding = materialBinding->getColorTargetBinding(j);
-			materialBinding->clearTexture(colorBinding->name);
-            
-            if(finalTargetColorTexture) {
-                materialBinding->addTexture(colorBinding->name, finalTargetColorTexture);
-            } else {
-                materialBinding->addTexture(colorBinding->name, renderer->getGlobalColorFramebuffer());
-            }
+            materialBinding->setTextureForParam(colorBinding->name, finalTargetBuffer->colorTexture);
 		}
 
 		for(int j=0; j < materialBinding->getNumDepthTargetBindings(); j++) {
 			RenderTargetBinding *depthBinding = materialBinding->getDepthTargetBinding(j);
-			materialBinding->clearTexture(depthBinding->name);
-            if(finalTargetZTexture) {
-                materialBinding->addTexture(depthBinding->name, finalTargetZTexture);
+            materialBinding->setTextureForParam(depthBinding->name, finalTargetBuffer->depthTexture);
+		}
+
+		if(i == filterShaderMaterial->getNumShaderPasses()-1) {
+            GPUDrawBuffer *drawBuffer = new GPUDrawBuffer();
+            drawBuffer->clearColorBuffer = true;
+            drawBuffer->clearDepthBuffer = true;
+            drawBuffer->globalMaterial = NULL;
+            if(targetBuffer) {
+                drawBuffer->targetFramebuffer = targetBuffer;
+                drawBuffer->viewport.setRect(0.0, 0.0, targetBuffer->getWidth(), targetBuffer->getHeight());
             } else {
-                materialBinding->addTexture(depthBinding->name, renderer->getGlobalDepthFramebuffer());
+                drawBuffer->targetFramebuffer = NULL;
+                drawBuffer->viewport = getViewport();
             }
-		}
-		
-		renderer->applyMaterial(filterShaderMaterial, localShaderOptions[i], i, true);
-		if(i==filterShaderMaterial->getNumShaders()-1) {
-				if(targetTexture) {
-					renderer->setViewportSize(targetTextureWidth, targetTextureHeight);	
-					renderer->bindFrameBufferTexture(targetTexture);								
-					renderer->clearScreen();
-					renderer->loadIdentity();
-                    // RENDERER_TODO
-					//renderer->drawScreenQuad(targetTextureWidth, targetTextureHeight);
-					renderer->unbindFramebuffers();									
-				} else {
-                    // global framebuffer ONLY used for input
-                    // we must unbind it here.
-                    // this is a bit of a hack, a better system
-                    // would be to define override buffers
-                    if(useGlobalFramebuffer) {
-                        renderer->unbindFramebuffers();
-                    }
-					renderer->setViewportSize(renderer->getXRes(), renderer->getYRes());
-					renderer->clearScreen();
-					renderer->loadIdentity();
-                    // RENDERER_TODO
-
-					//renderer->drawScreenQuad(renderer->getXRes(), renderer->getYRes());
-				}
+            renderFullScreenQuad(drawBuffer, i);
+            renderer->processDrawBuffer(drawBuffer);
 		} 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_TODO
-					//renderer->drawScreenQuad(bindingTexture->getWidth(), bindingTexture->getHeight());
-					renderer->unbindFramebuffers();
+				RenderBuffer *bindingBuffer = materialBinding->getOutTargetBinding(j)->buffer;
+				if(bindingBuffer) {
+                    GPUDrawBuffer *drawBuffer = new GPUDrawBuffer();
+                    drawBuffer->clearColorBuffer = true;
+                    drawBuffer->clearDepthBuffer = true;
+                    drawBuffer->globalMaterial = NULL;
+					drawBuffer->viewport.setRect(0.0, 0.0, bindingBuffer->getWidth(), bindingBuffer->getHeight());
+                    drawBuffer->targetFramebuffer = bindingBuffer;
+                    renderFullScreenQuad(drawBuffer, i);                    
+                    renderer->processDrawBuffer(drawBuffer);
 				}
 			}		
 		}
-		renderer->clearShader();
-		renderer->loadIdentity();
 	}
- */
 }
 
 Matrix4 Camera::getProjectionMatrix() {

src/core/PolyIOSCore.mm

@@ -133,8 +133,6 @@ String IOSCore::executeExternalCommand(String command, String args, String inDir
 }
 
 
-
-
 bool IOSCore::systemParseFolder(const Polycode::String& pathString, bool showHidden, std::vector<OSFileEntry> &targetVector) {
 
 	return true; 

src/core/PolyMaterialManager.cpp

@@ -575,7 +575,7 @@ Material *MaterialManager::materialFromXMLNode(ResourcePool *resourcePool, TiXml
 								for(int l=0; l < renderTargets.size(); l++) {
 									if(renderTargets[l]->id == newBinding->id) {
 										printf("Assigning texture to %s\n", newBinding->id.c_str());
-										newBinding->texture = renderTargets[l]->texture;
+										newBinding->buffer = renderTargets[l]->buffer;
 									}
 								}
 								

src/core/PolySceneManager.cpp

@@ -86,7 +86,7 @@ void SceneManager::Render(const Polycode::Rectangle &viewport) {
 		if(scenes[i]->isEnabled() && !scenes[i]->isVirtual()) {
 			Scene *scene = scenes[i];
 			if(scene->getActiveCamera()->hasFilterShader()) {
-				scene->getActiveCamera()->drawFilter();
+				scene->getActiveCamera()->drawFilter(NULL);
 			} else {
                 scene->getActiveCamera()->setViewport(viewport);
 				scene->Render(NULL, NULL, NULL, true);

src/core/PolySceneMesh.cpp

@@ -367,6 +367,7 @@ void SceneMesh::Render(GPUDrawBuffer *buffer) {
     
     buffer->drawCalls.push_back(drawCall);
     
+    // RENDERERTODO: FIX GPU SKINNING
     /*
    	if(material) {
         

src/core/PolySceneRenderTexture.cpp

@@ -68,14 +68,12 @@ Camera *SceneRenderTexture::getTargetCamera() {
 }
 
 void SceneRenderTexture::Render() {
-    
-    // RENDERER_TODO
-//    if(targetCamera->hasFilterShader()) {
-       // targetCamera->drawFilter(targetTexture, targetTexture->getWidth(), targetTexture->getHeight(), filterColorBufferTexture, filterZBufferTexture);
-  //  } else {
+    if(targetCamera->hasFilterShader()) {
+        targetCamera->drawFilter(targetFramebuffer);
+    } else {
         targetCamera->setViewport(Polycode::Rectangle(0.0, 0.0, targetFramebuffer->getWidth(), targetFramebuffer->getHeight()));
         targetScene->Render(targetCamera, targetFramebuffer, NULL, true);
-   // }
+    }
 }
 
 Image *SceneRenderTexture::saveToImage() {

src/core/PolyShader.cpp

@@ -27,7 +27,7 @@
 using namespace Polycode;
 
 ShaderRenderTarget::ShaderRenderTarget() : PolyBase() {
-	texture = NULL;
+	buffer = NULL;
 }
 
 ProgramParam::ProgramParam() : type(PARAM_UNKNOWN), platformData(NULL), globalParam(NULL) {