Blending + particles

include/anki/gl/GlState.h

@@ -74,6 +74,8 @@ public:
 	void setClearDepthValue(const GLfloat depth);
 
 	void setClearStencilValue(const GLint s);
+
+	void setBlendFunctions(const GLenum sFactor, const GLenum dFactor);
 	/// @}
 
 private:
@@ -84,6 +86,7 @@ private:
 	Vec4 clearColor;
 	GLfloat clearDepthValue;
 	GLint clearStencilValue;
+	Array<GLenum, 2> blendFuncs;
 
 	// XXX
 	GLenum depthFunc; 

include/anki/renderer/Bs.h

@@ -20,17 +20,8 @@ public:
 
 	void init(const RendererInitializer& initializer);
 	void run();
-
-private:
-	Fbo fbo; ///< Writes to Pps::prePassFai
-	Fbo refractFbo; ///< Writes to refractFai
-	ShaderProgramResourcePointer refractSProg;
-	Texture refractFai;
-
-	void createFbo();
-	void createRefractFbo();
 };
 
-} // end namespace
+} // end namespace anki
 
 #endif

include/anki/renderer/Drawer.h

@@ -16,6 +16,12 @@ class RenderableDrawer
 public:
 	static const U UNIFORM_BLOCK_MAX_SIZE = 256;
 
+	enum RenderingStage
+	{
+		RS_MATERIAL,
+		RS_BLEND
+	};
+
 	/// The one and only constructor
 	RenderableDrawer(Renderer* r_)
 		: r(r_)
@@ -25,7 +31,7 @@ public:
 	{}
 
 	void render(const Frustumable& fr,
-		U32 pass, Renderable& renderable);
+		RenderingStage stage, U32 pass, Renderable& renderable);
 
 private:
 	Renderer* r;

shaders/BsFragmentCommon.glsl

@@ -0,0 +1,21 @@
+#define vTexCoords_DEFINED
+in vec2 vTexCoords;
+
+#if defined(PASS_COLOR)
+layout(location = 0) out vec4 fColor;
+#	define fColor_DEFINED
+#endif
+
+#pragma anki include "shaders/MaterialCommonFunctions.glsl"
+
+#if defined(PASS_COLOR)
+#	define texture_DEFINED
+#endif
+
+#if defined(PASS_COLOR)
+#	define writeFais_DEFINED
+void writeFais(in vec4 color)
+{
+	fColor = color;
+}
+#endif

shaders/GaussianBlurGeneric.glsl

@@ -25,6 +25,8 @@ void main()
 
 #pragma anki start fragmentShader
 
+precision mediump float;
+
 // Preprocessor switches sanity checks
 #if !defined(VPASS) && !defined(HPASS)
 #	error "See file"
@@ -38,7 +40,7 @@ void main()
 #	error "See file"
 #endif
 
-uniform sampler2D img; ///< Input FAI
+uniform mediump sampler2D img; ///< Input FAI
 
 in vec2 vTexCoords;
 in vec2 vOffsets;

src/gl/GlState.cpp

@@ -102,6 +102,10 @@ void GlState::sync()
 
 	// clear stencil value
 	glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &clearStencilValue);
+
+	// blend funcs
+	glGetIntegerv(GL_BLEND_SRC, (GLint*)&blendFuncs[0]);
+	glGetIntegerv(GL_BLEND_DST, (GLint*)&blendFuncs[1]);
 }
 
 //==============================================================================
@@ -168,4 +172,23 @@ void GlState::setClearStencilValue(const GLint s)
 	}
 }
 
+//==============================================================================
+void GlState::setBlendFunctions(const GLenum sFactor, const GLenum dFactor)
+{
+#if ANKI_DEBUG
+	GLint real;
+	glGetIntegerv(GL_BLEND_SRC, &real);
+	ANKI_ASSERT(blendFuncs[0] == (GLenum)real);
+	glGetIntegerv(GL_BLEND_DST, &real);
+	ANKI_ASSERT(blendFuncs[1] == (GLenum)real);
+#endif
+
+	if(sFactor != blendFuncs[0] || dFactor != blendFuncs[1])
+	{
+		glBlendFunc(sFactor, dFactor);
+		blendFuncs[0] = sFactor;
+		blendFuncs[1] = dFactor;
+	}
+}
+
 } // end namespace anki

src/renderer/Bs.cpp

@@ -1,6 +1,7 @@
 #include "anki/renderer/Bs.h"
 #include "anki/renderer/Renderer.h"
-#include "anki/resource/ShaderProgramResource.h"
+#include "anki/scene/Scene.h"
+#include "anki/scene/Camera.h"
 
 namespace anki {
 
@@ -8,57 +9,27 @@ namespace anki {
 Bs::~Bs()
 {}
 
-//==============================================================================
-void Bs::createFbo()
-{
-#if 0
-	try
-	{
-		fbo.create();
-
-		fbo.setColorAttachments({&r->getPps().getPrePassFai()});
-		fbo.setOtherAttachment(GL_DEPTH_STENCIL_ATTACHMENT, 
-			r->getMs().getDepthFai());
-	}
-	catch(std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Failed to create blending stage FBO") << e;
-	}
-#endif
-}
-
-//==============================================================================
-void Bs::createRefractFbo()
-{
-	try
-	{
-		refractFbo.create();
-
-		refractFbo.setColorAttachments({&refractFai});
-		refractFbo.setOtherAttachment(GL_DEPTH_STENCIL_ATTACHMENT, 
-			r->getMs().getDepthFai());
-	}
-	catch(std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Failed to create blending stage refract FBO") 
-			<< e;
-	}
-}
-
 //==============================================================================
 void Bs::init(const RendererInitializer& /*initializer*/)
 {
-	createFbo();
-	Renderer::createFai(r->getWidth(), r->getHeight(), GL_RGBA8, GL_RGBA,
-		GL_FLOAT, refractFai);
-	createRefractFbo();
-	refractSProg.load("shaders/BsRefract.glsl");
+	// Do nothing
 }
 
 //==============================================================================
 void Bs::run()
 {
-	/// XXX
+	RenderableDrawer& drawer = r->getSceneDrawer();
+	drawer.prepareDraw();
+	Scene& scene = r->getScene();
+	VisibilityInfo& vi =
+		scene.getActiveCamera().getFrustumable()->getVisibilityInfo();
+
+	for(auto it = vi.getRenderablesEnd() - 1; it >= vi.getRenderablesBegin();
+		--it)
+	{
+		drawer.render(scene.getActiveCamera(), RenderableDrawer::RS_BLEND,
+			0, *((*it)->getRenderable()));
+	}
 }
 
-} // end namespace
+} // end namespace anki

src/renderer/Drawer.cpp

@@ -89,7 +89,7 @@ struct SetupMaterialVariableVisitor
 
 				for(U i = 0; i < instancesCount; i++)
 				{
-					mvps[i] = vpMat * Mat4(trfs[0]);
+					mvps[i] = vpMat * Mat4(trfs[i]);
 				}
 
 				uni->set(&mvps[0], instancesCount);
@@ -180,9 +180,33 @@ void RenderableDrawer::setupShaderProg(
 }
 
 //==============================================================================
-void RenderableDrawer::render(const Frustumable& fr, U32 pass,
-	Renderable& renderable)
+void RenderableDrawer::render(const Frustumable& fr, RenderingStage stage,
+	U32 pass, Renderable& renderable)
 {
+	const Material& mtl = renderable.getRenderableMaterial();
+
+	Bool blending = mtl.isBlendingEnabled();
+
+	if(blending)
+	{
+		if(stage != RS_BLEND)
+		{
+			return;
+		}
+
+		GlStateSingleton::get().setBlendFunctions(
+			mtl.getBlendingSfactor(), mtl.getBlendingDfactor());
+	}
+	else
+	{
+		if(stage == RS_BLEND)
+		{
+			return;
+		}
+	}
+
+	GlStateSingleton::get().enable(GL_BLEND, blending);
+
 	/*float dist = (node.getWorldTransform().getOrigin() -
 		cam.getWorldTransform().getOrigin()).getLength();
 	uint lod = std::min(r.calculateLod(dist), mtl.getLevelsOfDetail() - 1);*/

src/renderer/Ez.cpp

@@ -33,7 +33,8 @@ void Ez::run()
 	for(auto it = vi.getRenderablesBegin();
 		it != vi.getRenderablesEnd() && count < maxObjectsToDraw; ++it)
 	{
-		r->getSceneDrawer().render(cam, 0, *((*it)->getRenderable()));
+		r->getSceneDrawer().render(cam, RenderableDrawer::RS_MATERIAL,
+			0, *((*it)->getRenderable()));
 		++count;
 	}
 

src/renderer/Is.cpp

@@ -598,6 +598,8 @@ void Is::run()
 	Scene& scene = r->getScene();
 	cam = &scene.getActiveCamera();
 
+	GlStateSingleton::get().disable(GL_BLEND);
+
 	// Ground light direction
 	Vec3 groundLightDir;
 	if(groundLightEnabled)

src/renderer/Ms.cpp

@@ -78,8 +78,8 @@ void Ms::run()
 		r->getScene().getActiveCamera().getFrustumable()->getVisibilityInfo();
 	for(auto it = vi.getRenderablesBegin(); it != vi.getRenderablesEnd(); ++it)
 	{
-		r->getSceneDrawer().render(r->getScene().getActiveCamera(), 0, 
-			*((*it)->getRenderable()));
+		r->getSceneDrawer().render(r->getScene().getActiveCamera(),
+			RenderableDrawer::RS_MATERIAL, 0, *((*it)->getRenderable()));
 	}
 
 	// restore depth

src/renderer/Pps.cpp

@@ -80,6 +80,8 @@ void Pps::run()
 {
 	ANKI_ASSERT(enabled);
 
+	GlStateSingleton::get().disable(GL_BLEND);
+
 	// First SSAO because it depends on MS where HDR depends on IS
 	if(ssao.getEnabled())
 	{

src/renderer/Renderer.cpp

@@ -34,6 +34,7 @@ void Renderer::init(const RendererInitializer& initializer)
 
 	ms.init(initializer);;
 	is.init(initializer);
+	bs.init(initializer);
 	pps.init(initializer);
 	bs.init(initializer);
 
@@ -83,11 +84,11 @@ void Renderer::render(Scene& scene_)
 	tiler.updateTiles(scene->getActiveCamera(), ms.getDepthFai());
 	ms.run();
 	is.run();
+	bs.run();
 	if(pps.getEnabled())
 	{
 		pps.run();
 	}
-	//bs.run();
 
 	ANKI_CHECK_GL_ERROR();
 	++framesNum;

src/renderer/Sm.cpp

@@ -167,6 +167,7 @@ Sm::Shadowmap* Sm::doLight(Light& light)
 		SceneNode* node = *it;
 		Frustumable* bfr = node->getFrustumable();
 		Movable* bmov = node->getMovable();
+		Spatial* sp = node->getSpatial();
 
 		if(bfr)
 		{
@@ -177,6 +178,11 @@ Sm::Shadowmap* Sm::doLight(Light& light)
 		{
 			lastUpdate = std::max(lastUpdate, bmov->getMovableTimestamp());
 		}
+
+		if(sp)
+		{
+			lastUpdate = std::max(lastUpdate, sp->getSpatialTimestamp());
+		}
 	}
 
 	Bool shouldUpdate = lastUpdate >= sm.timestamp;
@@ -198,7 +204,8 @@ Sm::Shadowmap* Sm::doLight(Light& light)
 
 	for(auto it = vi.getRenderablesBegin(); it != vi.getRenderablesEnd(); ++it)
 	{
-		r->getSceneDrawer().render(*fr, 1, *((*it)->getRenderable()));
+		r->getSceneDrawer().render(*fr, RenderableDrawer::RS_MATERIAL,
+			1, *((*it)->getRenderable()));
 	}
 
 	return &sm;

testapp/Main.cpp

@@ -306,10 +306,10 @@ void mainLoopExtra()
 	{
 		mover = SceneSingleton::get().findSceneNode("spot1").getMovable();
 	}
-	/*if(in.getKey(KC_5))
+	if(in.getKey(KC_5))
 	{
-		mover = SceneSingleton::get().findSceneNode("point1")->getMovable();
-	}*/
+		mover = SceneSingleton::get().findSceneNode("pe").getMovable();
+	}
 	if(in.getKey(KC_6))
 	{
 		mover = SceneSingleton::get().findSceneNode("camera1").getMovable();
@@ -457,7 +457,7 @@ void initSubsystems(int argc, char* argv[])
 	// Main renderer
 	RendererInitializer initializer;
 	initializer.ms.ez.enabled = true;
-	initializer.dbg.enabled = true;
+	initializer.dbg.enabled = false;
 	initializer.is.sm.bilinearEnabled = true;
 	initializer.is.groundLightEnabled = false;
 	initializer.is.sm.enabled = true;