Lens flare occlusion tests are implemented. Some bugs remain

include/anki/gl/GlCommandBufferHandle.h

@@ -154,6 +154,10 @@ public:
 		GLenum mode, U8 indexSize, 
 		U32 count, U32 instanceCount = 1, U32 firstIndex = 0,
 		U32 baseVertex = 0, U32 baseInstance = 0);
+
+	void drawArraysConditional(GlOcclusionQueryHandle& query,
+		GLenum mode, U32 count, U32 instanceCount = 1,
+		U32 first = 0, U32 baseInstance = 0);
 	/// @}
 
 	/// @privatesection

include/anki/renderer/Lf.h

@@ -20,56 +20,68 @@ namespace anki {
 /// Lens flare rendering pass
 class Lf: public RenderingPass
 {
-	friend class Pps;
-
 public:
 	/// @privatesection
 	/// @{
+	Lf(Renderer* r)
+	:	RenderingPass(r)
+	{}
+
+	~Lf();
+
 	const GlTextureHandle& _getRt() const
 	{
 		return m_rt;
 	}
+
 	GlTextureHandle& _getRt()
 	{
 		return m_rt;
 	}
 
-	Error runOcclusionTests(GlCommandBufferHandle& cmdb);
+	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+
+	ANKI_USE_RESULT Error runOcclusionTests(GlCommandBufferHandle& cmdb);
+
+	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
 	/// @}
 
 private:
+	GlTextureHandle m_rt;
+	GlFramebufferHandle m_fb;
+
+	// Occlusion query
+	GlBufferHandle m_positionsVertBuff;
+	GlBufferHandle m_mvpBuff;
+	ProgramResourcePointer m_occlusionVert;
+	ProgramResourcePointer m_occlusionFrag;
+	GlPipelineHandle m_occlusionPpline;
+
 	// Pseudo flares
 	ProgramResourcePointer m_pseudoFrag;
 	GlPipelineHandle m_pseudoPpline;
+	TextureResourcePointer m_lensDirtTex;
+	U8 m_maxSpritesPerFlare;
+	U8 m_maxFlares;
 
 	// Sprite billboards
 	ProgramResourcePointer m_realVert;
 	ProgramResourcePointer m_realFrag;
 	GlPipelineHandle m_realPpline;
+	GlBufferHandle m_flareDataBuff;
+	U32 m_flareSize;
 
 	// Final HDR blit
 	ProgramResourcePointer m_blitFrag;
 	GlPipelineHandle m_blitPpline;
 
-	GlTextureHandle m_rt;
-	GlFramebufferHandle m_fb;
-
-	TextureResourcePointer m_lensDirtTex;
-	U8 m_maxSpritesPerFlare;
-	U8 m_maxFlares;
-	GlBufferHandle m_flareDataBuff;
+	ANKI_USE_RESULT Error initPseudo(
+		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error initSprite(
+		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
+	ANKI_USE_RESULT Error initOcclusion(
+		const ConfigSet& config, GlCommandBufferHandle& cmdBuff);
 
-	U32 m_flareSize;
-
-	Lf(Renderer* r)
-	:	RenderingPass(r)
-	{}
-
-	~Lf();
-
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(GlCommandBufferHandle& jobs);
-	
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 };
 

include/anki/renderer/Renderer.h

@@ -210,6 +210,9 @@ public:
 	/// longer support quads
 	void drawQuad(GlCommandBufferHandle& cmdBuff);
 
+	void drawQuadConditional(
+		GlOcclusionQueryHandle& q, GlCommandBufferHandle& cmdBuff);
+
 	void drawQuadInstanced(GlCommandBufferHandle& cmdBuff, U32 primitiveCount);
 
 	/// Get the LOD given the distance of an object from the camera
@@ -225,7 +228,7 @@ public:
 
 	/// Create a pipeline object that has as a vertex shader the m_drawQuadVert
 	/// and the given fragment progam
-	ANKI_USE_RESULT Error createDrawQuadProgramPipeline(
+	ANKI_USE_RESULT Error createDrawQuadPipeline(
 		GlShaderHandle frag, GlPipelineHandle& ppline);
 
 	/// Init the renderer given an initialization class

shaders/Blit.frag.glsl

@@ -8,9 +8,9 @@
 
 layout(binding = 0) uniform lowp sampler2D uTex;
 
-layout(location = 0) in F32Vec2 inTexCoords;
+layout(location = 0) in vec2 inTexCoords;
 
-layout(location = 0) out F16Vec3 outColor;
+layout(location = 0) out vec3 outColor;
 
 void main()
 {

shaders/Common.glsl

@@ -21,41 +21,11 @@
 precision DEFAULT_FLOAT_PRECISION float;
 precision DEFAULT_FLOAT_PRECISION int;
 
-// Types
-#define F16 mediump float
-#define F32 highp float
-#define U32 highp uint
-#define I32 highp int
-
-#define F16Vec2 mediump vec2
-#define F32Vec2 highp vec2
-#define U32Vec2 highp uvec2
-#define I32Vec2 highp ivec2
-
-#define F16Vec3 mediump vec3
-#define F32Vec3 highp vec3
-#define U32Vec3 highp uvec3
-#define I32Vec3 highp ivec3
-
-#define F16Vec4 mediump vec4
-#define F32Vec4 highp vec4
-#define U32Vec4 highp uvec4
-#define I32Vec4 highp ivec4
-
-#define F32Mat4 highp mat4
-#define F16Mat4 mediump mat4
-
-#define F32Mat3 highp mat3
-#define F16Mat3 mediump mat3
-
-#define F32Sampler2D highp sampler2D
-#define F16Sampler2D mediump sampler2D
-
 // Read from a render target texture
 //#define textureRt(tex_, texc_) texture(tex_, texc_)
 #define textureRt(tex_, texc_) textureLod(tex_, texc_, 0.0)
 
-// Commpn locations
+// Common locations
 #define POSITION_LOCATION 0
 #define NORMAL_LOCATION 1
 #define TANGENT_LOCATION 2

shaders/PpsLfOcclusion.frag.glsl

@@ -0,0 +1,13 @@
+// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+// PPS LF occlusion frag shader
+
+#pragma anki type frag
+#pragma anki include "shaders/Common.glsl"
+
+void main()
+{}
+

shaders/PpsLfOcclusion.vert.glsl

@@ -0,0 +1,27 @@
+// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+// PPS LF occlusion vert shader
+#pragma anki type vert
+
+layout(std140) uniform _block
+{
+	mat4 u_mvp;
+};
+
+layout(location = 0) in vec3 in_position;
+
+out gl_PerVertex
+{
+	vec4 gl_Position;
+	float gl_PointSize;
+};
+
+void main()
+{
+	gl_Position = u_mvp * vec4(in_position, 1.0);
+	gl_PointSize = 8.0;
+}
+

shaders/PpsLfSpritePass.vert.glsl

@@ -14,15 +14,15 @@ struct Flare
 };
 
 // The block contains data for all flares
-layout(std140) uniform bFlares
+layout(std140) uniform _flaresBlock
 {
-	Flare uFlares[MAX_SPRITES];
+	Flare u_flares[MAX_SPRITES];
 };
 
-layout(location = 0) in vec2 inPosition;
+layout(location = 0) in vec2 in_position;
 
-layout(location = 0) out vec3 outTexCoord;
-layout(location = 1) flat out float outAlpha;
+layout(location = 0) out vec3 out_texCoord;
+layout(location = 1) flat out float out_alpha;
 
 out gl_PerVertex
 {
@@ -31,12 +31,12 @@ out gl_PerVertex
 
 void main()
 {
-	Flare flare = uFlares[gl_InstanceID];
+	Flare flare = u_flares[gl_InstanceID];
 
-	outTexCoord = vec3((inPosition * 0.5) + 0.5, flare.alphaDepth.y);
+	out_texCoord = vec3((in_position * 0.5) + 0.5, flare.alphaDepth.y);
 
 	vec4 posScale = flare.posScale;
-	gl_Position = vec4(inPosition * posScale.zw + posScale.xy , 0.0, 1.0);
+	gl_Position = vec4(in_position * posScale.zw + posScale.xy , 0.0, 1.0);
 
-	outAlpha = flare.alphaDepth.x;
+	out_alpha = flare.alphaDepth.x;
 }

shaders/Quad.vert.glsl

@@ -9,7 +9,7 @@
 /// the vert coords are NDC
 layout(location = POSITION_LOCATION) in vec2 inPosition;
 
-layout(location = 0) out F32Vec2 outTexCoord;
+layout(location = 0) out vec2 outTexCoord;
 
 out gl_PerVertex
 {

src/gl/GlCommandBufferHandle.cpp

@@ -697,4 +697,62 @@ void GlCommandBufferHandle::drawElementsConditional(
 	}
 }
 
+//==============================================================================
+// Use the template trick to avoid allocating too much things in the 
+// command buffer
+template<GLenum mode>
+class DrawArraysCondCommand: public GlCommand
+{
+public:
+	GlDrawArraysIndirectInfo m_info;
+	GlOcclusionQueryHandle m_query;
+
+	DrawArraysCondCommand(
+		GlDrawArraysIndirectInfo& info, GlOcclusionQueryHandle& q)
+	:	m_info(info),
+		m_query(q)
+	{}
+
+	Error operator()(GlCommandBuffer*)
+	{
+		if(m_query._get().getResult() != GlOcclusionQuery::Result::NOT_VISIBLE)
+		{
+			glDrawArraysInstancedBaseInstance(
+				mode,
+				m_info.m_first,
+				m_info.m_count,
+				m_info.m_instanceCount,
+				m_info.m_baseInstance);
+		}
+
+		ANKI_COUNTER_INC(GL_DRAWCALLS_COUNT, (U64)1);
+
+		return ErrorCode::NONE;
+	}
+};
+
+void GlCommandBufferHandle::drawArraysConditional(GlOcclusionQueryHandle& q,
+	GLenum mode, U32 count, U32 instanceCount, U32 first, U32 baseInstance)
+{
+	GlDrawArraysIndirectInfo info(count, instanceCount, first, baseInstance);
+
+	switch(mode)
+	{
+	case GL_TRIANGLES:
+		_pushBackNewCommand<DrawArraysCondCommand<GL_TRIANGLES>>(info, q);
+		break;
+	case GL_TRIANGLE_STRIP:
+		_pushBackNewCommand<DrawArraysCondCommand<GL_TRIANGLE_STRIP>>(info, q);
+		break;
+	case GL_POINTS:
+		_pushBackNewCommand<DrawArraysCondCommand<GL_POINTS>>(info, q);
+		break;
+	case GL_LINES:
+		_pushBackNewCommand<DrawArraysCondCommand<GL_LINES>>(info, q);
+		break;
+	default:
+		ANKI_ASSERT(0 && "Not implemented");
+	}
+}
+
 } // end namespace anki

src/renderer/Hdr.cpp

@@ -86,7 +86,7 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	err = m_toneFrag.load("shaders/PpsHdr.frag.glsl", &getResourceManager());
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_toneFrag->getGlProgram(), m_tonePpline);
 	if(err) return err;
 
@@ -109,7 +109,7 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 		SHADER_FILENAME, pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_hblurFrag->getGlProgram(), m_hblurPpline);
 	if(err) return err;
 
@@ -128,7 +128,7 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 		SHADER_FILENAME, pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_vblurFrag->getGlProgram(), m_vblurPpline);
 	if(err) return err;
 

src/renderer/Lf.cpp

@@ -49,19 +49,10 @@ Error Lf::init(const ConfigSet& config)
 }
 
 //==============================================================================
-Error Lf::initInternal(const ConfigSet& config)
+Error Lf::initPseudo(const ConfigSet& config, 
+	GlCommandBufferHandle& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
-	m_enabled = config.get("pps.lf.enabled") 
-		&& config.get("pps.hdr.enabled");
-	if(!m_enabled)
-	{
-		return err;
-	}
-
-	GlCommandBufferHandle cmdBuff;
-	err = cmdBuff.create(&getGlDevice());
-	if(err) return err;
 
 	m_maxSpritesPerFlare = config.get("pps.lf.maxSpritesPerFlare");
 	m_maxFlares = config.get("pps.lf.maxFlares");
@@ -80,18 +71,31 @@ Error Lf::initInternal(const ConfigSet& config)
 		"shaders/PpsLfPseudoPass.frag.glsl", pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_pseudoFrag->getGlProgram(), m_pseudoPpline);
 	if(err) return err;
 
-	// Load program 2
-	pps.destroy(getAllocator());
+	// Textures
+	err = m_lensDirtTex.load(
+		"engine_data/lens_dirt.ankitex", &getResourceManager());
+	if(err) return err;
+
+	return err;
+}
+
+//==============================================================================
+Error Lf::initSprite(const ConfigSet& config, 
+	GlCommandBufferHandle& cmdBuff)
+{
+	Error err = ErrorCode::NONE;
+
+	// Load program + ppline
+	String pps;
+	String::ScopeDestroyer ppsd(&pps, getAllocator());
+
 	err = pps.sprintf(getAllocator(), "#define MAX_SPRITES %u\n",
 		m_maxSpritesPerFlare);
-	if(err)
-	{
-		return err;
-	}
+	if(err)	return err;
 
 	err = m_realVert.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfSpritePass.vert.glsl", pps.toCString(), "r_");
@@ -105,17 +109,78 @@ Error Lf::initInternal(const ConfigSet& config)
 		{m_realVert->getGlProgram(), m_realFrag->getGlProgram()});
 	if(err) return err;
 
+	// Create buffer
 	PtrSize uboAlignment = 
 		m_r->_getGlDevice().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 	m_flareSize = getAlignedRoundUp(
 		uboAlignment, sizeof(Sprite) * m_maxSpritesPerFlare);
 	PtrSize blockSize = m_flareSize * m_maxFlares;
 
-	// Init buffer
 	err = m_flareDataBuff.create(
 		cmdBuff, GL_UNIFORM_BUFFER, blockSize, GL_DYNAMIC_STORAGE_BIT);
 	if(err) return err;
 
+	return err;
+}
+
+//==============================================================================
+Error Lf::initOcclusion(
+	const ConfigSet& config, GlCommandBufferHandle& cmdBuff)
+{
+	Error err = ErrorCode::NONE;
+
+	// Init vert buff
+	U buffSize = sizeof(Vec3) * m_maxFlares;
+
+	err = m_positionsVertBuff.create(
+		cmdBuff, GL_ARRAY_BUFFER, buffSize, GL_DYNAMIC_STORAGE_BIT);
+	if(err) return err;
+
+	// Init MVP buff
+	err = m_mvpBuff.create(
+		cmdBuff, GL_UNIFORM_BUFFER, sizeof(Mat4), GL_DYNAMIC_STORAGE_BIT);
+	if(err) return err;
+
+	// Shaders
+	err = m_occlusionVert.load("shaders/PpsLfOcclusion.vert.glsl",
+		&getResourceManager());
+	if(err) return err;
+
+	err = m_occlusionFrag.load("shaders/PpsLfOcclusion.frag.glsl",
+		&getResourceManager());
+	if(err) return err;
+
+	err = m_occlusionPpline.create(cmdBuff,
+		{m_occlusionVert->getGlProgram(), m_occlusionFrag->getGlProgram()});
+	if(err) return err;
+
+	return err;
+}
+
+//==============================================================================
+Error Lf::initInternal(const ConfigSet& config)
+{
+	Error err = ErrorCode::NONE;
+	m_enabled = config.get("pps.lf.enabled") 
+		&& config.get("pps.hdr.enabled");
+	if(!m_enabled)
+	{
+		return err;
+	}
+
+	GlCommandBufferHandle cmdBuff;
+	err = cmdBuff.create(&getGlDevice());
+	if(err) return err;
+
+	err = initPseudo(config, cmdBuff);
+	if(err) return err;
+
+	err = initSprite(config, cmdBuff);
+	if(err) return err;
+
+	err = initOcclusion(config, cmdBuff);
+	if(err) return err;
+
 	// Create the render target
 	err = m_r->createRenderTarget(m_r->getPps().getHdr()._getWidth(), 
 		m_r->getPps().getHdr()._getHeight(), 
@@ -124,21 +189,16 @@ Error Lf::initInternal(const ConfigSet& config)
 
 	err = m_fb.create(cmdBuff, {{m_rt, GL_COLOR_ATTACHMENT0}});
 	if(err) return err;
-	
-	// Textures
-	err = m_lensDirtTex.load(
-		"engine_data/lens_dirt.ankitex", &getResourceManager());
-	if(err) return err;
 
 	// Blit
 	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_blitFrag->getGlProgram(), m_blitPpline);
 	if(err) return err;
 
-	cmdBuff.finish();
+	cmdBuff.flush();
 
 	return err;
 }
@@ -161,6 +221,28 @@ Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
 		cmdb.setColorWriteMask(false, false, false, false);
 		cmdb.setDepthWriteMask(false);
 		cmdb.enableDepthTest(true);
+		m_occlusionPpline.bind(cmdb);
+
+		// Setup MVP UBO
+		GlClientBufferHandle mvpCBuff;
+		err = mvpCBuff.create(cmdb, sizeof(Mat4), nullptr);
+		if(err) return err;
+		Mat4* mvpWrite = static_cast<Mat4*>(mvpCBuff.getBaseAddress());
+		ANKI_ASSERT(mvpWrite);
+		*mvpWrite = cam.getViewProjectionMatrix().getTransposed();
+		m_mvpBuff.write(cmdb, mvpCBuff, 0, 0, sizeof(Mat4));
+		m_mvpBuff.bindShaderBuffer(cmdb, 0, sizeof(Mat4), 0);
+
+		// Allocate vertices and fire write job
+		GlClientBufferHandle posCBuff;
+		err = posCBuff.create(cmdb, sizeof(Vec3) * totalCount, nullptr);
+		if(err) return err;
+		m_positionsVertBuff.write(cmdb, posCBuff, 0, 0, posCBuff.getSize());
+		m_positionsVertBuff.bindVertexBuffer(
+			cmdb, 3, GL_FLOAT, false, sizeof(Vec3), 0, 0);
+
+		Vec3* positions = static_cast<Vec3*>(posCBuff.getBaseAddress());
+		Vec3* initialPositions = positions;
 
 		// Iterate lens flare
 		auto it = vi.getLensFlaresBegin();
@@ -170,10 +252,17 @@ Error Lf::runOcclusionTests(GlCommandBufferHandle& cmdb)
 			LensFlareComponent& lf = 
 				(it->m_node)->getComponent<LensFlareComponent>();
 
+			*positions = lf.getWorldPosition().xyz();
+
+			// Draw and query
 			GlOcclusionQueryHandle& query = lf.getOcclusionQueryToTest();
 			query.begin(cmdb);
 
+			cmdb.drawArrays(GL_POINTS, 1, 1, positions - initialPositions);
+			
 			query.end(cmdb);
+
+			++positions;
 		}
 
 		// Restore state
@@ -285,7 +374,7 @@ Error Lf::run(GlCommandBufferHandle& cmdBuff)
 				sizeof(Sprite) * count,
 				0);
 
-			m_r->drawQuad(cmdBuff);
+			m_r->drawQuadConditional(lf.getOcclusionQueryToCheck(), cmdBuff);
 
 			// Advance
 			U advancementSize = 

src/renderer/MainRenderer.cpp

@@ -42,7 +42,7 @@ Error MainRenderer::create(
 	err = m_blitFrag.load("shaders/Final.frag.glsl", &_getResourceManager());
 	if(err) return err;
 
-	err = createDrawQuadProgramPipeline(
+	err = createDrawQuadPipeline(
 		m_blitFrag->getGlProgram(), m_blitPpline);
 	if(err) return err;
 

src/renderer/Pps.cpp

@@ -83,7 +83,7 @@ Error Pps::initInternal(const ConfigSet& config)
 		"shaders/Pps.frag.glsl", pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(m_frag->getGlProgram(), m_ppline);
+	err = m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline);
 	if(err) return err;
 
 	cmdBuff.finish();

src/renderer/Renderer.cpp

@@ -170,6 +170,9 @@ Error Renderer::render(SceneGraph& scene,
 	cmdBuff[0].flush();
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_MS_TIME);
 
+	err = m_pps.getLf().runOcclusionTests(cmdBuff[1]);
+	if(err) return err;
+
 	err = m_dp.run(cmdBuff[1]);
 	if(err) return err;
 
@@ -208,6 +211,14 @@ void Renderer::drawQuad(GlCommandBufferHandle& cmdBuff)
 	drawQuadInstanced(cmdBuff, 1);
 }
 
+//==============================================================================
+void Renderer::drawQuadConditional(GlOcclusionQueryHandle& q,
+	GlCommandBufferHandle& cmdBuff)
+{
+	m_quadPositionsBuff.bindVertexBuffer(cmdBuff, 2, GL_FLOAT, false, 0, 0, 0);
+	cmdBuff.drawArraysConditional(q, GL_TRIANGLE_STRIP, 4, 1);
+}
+
 //==============================================================================
 void Renderer::drawQuadInstanced(
 	GlCommandBufferHandle& cmdBuff, U32 primitiveCount)
@@ -303,7 +314,7 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 }
 
 //==============================================================================
-Error Renderer::createDrawQuadProgramPipeline(
+Error Renderer::createDrawQuadPipeline(
 	GlShaderHandle frag, GlPipelineHandle& ppline)
 {
 	GlCommandBufferHandle cmdBuff;

src/renderer/RenderingPass.cpp

@@ -87,7 +87,7 @@ Error BlurringRenderingPass::initBlurring(
 			pps[i].toCString(), "r_");
 		if(err) return err;
 
-		err = r.createDrawQuadProgramPipeline(
+		err = r.createDrawQuadPipeline(
 			dir.m_frag->getGlProgram(), dir.m_ppline);
 		if(err) return err;
 	}

src/renderer/Ssao.cpp

@@ -201,7 +201,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 		"shaders/PpsSsao.frag.glsl", pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_ssaoFrag->getGlProgram(), m_ssaoPpline);
 	if(err) return err;
 
@@ -222,7 +222,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 		SHADER_FILENAME, pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_hblurFrag->getGlProgram(), m_hblurPpline);
 	if(err) return err;
 
@@ -239,7 +239,7 @@ Error Ssao::initInternal(const ConfigSet& config)
 		SHADER_FILENAME, pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_vblurFrag->getGlProgram(), m_vblurPpline);
 	if(err) return err;
 

src/renderer/Sslr.cpp

@@ -45,7 +45,7 @@ Error Sslr::init(const ConfigSet& config)
 		"shaders/PpsSslr.frag.glsl", pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_reflectionFrag->getGlProgram(), m_reflectionPpline);
 	if(err) return err;
 
@@ -60,7 +60,7 @@ Error Sslr::init(const ConfigSet& config)
 	// Blit
 	err = m_blitFrag.load("shaders/Blit.frag.glsl", &getResourceManager());
 	if(err) return err;
-	err = m_r->createDrawQuadProgramPipeline(
+	err = m_r->createDrawQuadPipeline(
 		m_blitFrag->getGlProgram(), m_blitPpline);
 	if(err) return err;
 

src/renderer/Tiler.cpp

@@ -250,7 +250,7 @@ Error Tiler::initInternal()
 		"shaders/TilerMinMax.frag.glsl", pps.toCString(), "r_");
 	if(err) return err;
 
-	err = m_r->createDrawQuadProgramPipeline(m_frag->getGlProgram(), m_ppline);
+	err = m_r->createDrawQuadPipeline(m_frag->getGlProgram(), m_ppline);
 	if(err) return err;
 
 	// Create FB

testapp/Main.cpp

@@ -144,10 +144,13 @@ Error init()
 		point->setDiffuseColor(Vec4(3.0, 0.2, 0.0, 0.0));
 		point->setSpecularColor(Vec4(1.0, 1.0, 0.0, 0.0));
 		
+		if(i == 0)
+		{
 		point->loadLensFlare("textures/lens_flare/flares0.ankitex");
 		LensFlareComponent& lf = point->getComponent<LensFlareComponent>();
 		lf.setFirstFlareSize(Vec2(0.5, 0.2));
 		lf.setColorMultiplier(Vec4(1.0, 1.0, 1.0, 0.6));
+		}
 
 		LightEvent* event;
 		err = scene.getEventManager().newEvent(event, 0.0, 0.8, point);
@@ -551,7 +554,7 @@ Error initSubsystems(int argc, char* argv[])
 	config.set("tilesYCount", 16);
 
 	config.set("fullscreenDesktopResolution", true);
-	config.set("debugContext", true);
+	config.set("debugContext", false);
 
 	app = new App;
 	err = app->create(config, allocAligned, nullptr);