IS & UBOS

include/anki/gl/ShaderProgram.h

@@ -329,10 +329,15 @@ public:
 	/// Used to find and return the variable. They return nullptr if the 
 	/// variable is not found
 	/// @{
-	const ShaderProgramVariable* findVariableByName(const char* varName) const;
-	const ShaderProgramUniformVariable* findUniformVariableByName(
+	const ShaderProgramVariable* tryFindVariable(const char* varName) const;
+	const ShaderProgramVariable& findVariable(const char* varName) const;
+	const ShaderProgramUniformVariable* tryFindUniformVariable(
 		const char* varName) const;
-	const ShaderProgramAttributeVariable* findAttributeVariableByName(
+	const ShaderProgramUniformVariable& findUniformVariable(
+		const char* varName) const;
+	const ShaderProgramAttributeVariable* tryFindAttributeVariable(
+		const char* varName) const;
+	const ShaderProgramAttributeVariable& findAttributeVariable(
 		const char* varName) const;
 	const ShaderProgramUniformBlock* tryFindUniformBlock(
 		const char* name) const;
@@ -389,7 +394,7 @@ private:
 	NameToAttribVarHashMap nameToAttribVar; ///< Attribute searching
 
 	UniformBlocksContainer blocks;
-	NameToUniformBlockHashMap namtToBlock;
+	NameToUniformBlockHashMap nameToBlock;
 	/// @}
 
 	/// Query the driver to get the vars. After the linking of the shader

include/anki/renderer/Hdr.h

@@ -34,7 +34,7 @@ public:
 	{
 		exposure = x;
 		toneSProg.bind();
-		toneSProg.findUniformVariableByName("exposure")->set(exposure);
+		toneSProg.findUniformVariable("exposure").set(exposure);
 	}
 
 	uint getBlurringIterationsNum() const
@@ -55,10 +55,10 @@ public:
 		blurringDist = x;
 
 		hblurSProg.bind();
-		hblurSProg.findUniformVariableByName("blurringDist")->set(
+		hblurSProg.findUniformVariable("blurringDist").set(
 			float(blurringDist / width));
 		vblurSProg.bind();
-		vblurSProg.findUniformVariableByName("blurringDist")->set(
+		vblurSProg.findUniformVariable("blurringDist").set(
 			float(blurringDist / height));
 	}
 

include/anki/scene/Light.h

@@ -53,15 +53,15 @@ public:
 		return type;
 	}
 
-	const Vec4& getColor() const
+	const Vec4& getDiffuseColor() const
 	{
 		return color;
 	}
-	Vec4& getColor()
+	Vec4& getDiffuseColor()
 	{
 		return color;
 	}
-	void setColor(const Vec4& x)
+	void setDiffuseColor(const Vec4& x)
 	{
 		color = x;
 	}
@@ -119,9 +119,9 @@ public:
 
 private:
 	LightType type;
-	Vec4 color;
-	Vec4 specColor;
-	bool shadow;
+	Vec4 color = Vec4(1.0);
+	Vec4 specColor = Vec4(1.0);
+	bool shadow = true;
 };
 
 /// Point light
@@ -164,7 +164,7 @@ public:
 
 public:
 	Sphere sphereW;
-	Sphere sphereL = {Vec3(0.0), 1.0};
+	Sphere sphereL = {Vec3(0.0), 2.0};
 };
 
 /// Spot light

include/anki/ui/UiPainter.h

@@ -36,7 +36,7 @@ public:
 	{
 		col = x;
 		sProg->bind();
-		sProg->findUniformVariableByName("color")->set(col);
+		sProg->findUniformVariable("color").set(col);
 	}
 
 	void setFont(const char* fontFilename, uint nominalWidth,

shaders/Final.glsl

@@ -6,7 +6,7 @@
 
 #pragma anki start fragmentShader
 
-#if 1
+#if 0
 uniform usampler2D rasterImage;
 #else
 uniform sampler2D rasterImage;
@@ -17,7 +17,7 @@ layout(location = 0) out vec3 fFragColor;
 
 void main()
 {
-#if 1
+#if 0
 	uvec2 a = texture2D(rasterImage, vTexCoords).rg;
 	vec4 diffAndSpec = unpackUnorm4x8(a.x);
 	fFragColor = diffAndSpec.rgb;

shaders/IsAp.glsl

@@ -8,7 +8,7 @@
 #pragma anki start fragmentShader
 
 uniform vec3 ambientCol;
-uniform sampler2D sceneColMap;
+uniform usampler2D msFai0;
 
 in vec2 vTexCoords;
 
@@ -16,5 +16,6 @@ out vec3 fColor;
 
 void main()
 {
-	fColor = texture2D(sceneColMap, vTexCoords).rgb * ambientCol;
+	vec4 c = unpackUnorm4x8(texture(msFai0, vTexCoords).r);
+	fColor = c.rgb * ambientCol;
 }

shaders/IsLpGeneric.glsl

@@ -30,7 +30,8 @@ layout(std140) uniform uniforms
 	uniform mat4 texProjectionMat;
 };
 
-uniform usampler2D msFai0, msDepthFai;
+uniform usampler2D msFai0;
+uniform sampler2D msDepthFai;
 uniform sampler2D lightTex;
 uniform sampler2DShadow shadowMap;
 /// @}
@@ -223,7 +224,7 @@ void main()
 #endif // spot light
 
 	
-	//fColor = fColor - fColor + vec3(1, 0, 1);
+	//fColor = vec3(texture(msDepthFai, vTexCoords).r);
 
 	//gl_FragData[0] = gl_FragData[0] - gl_FragData[0] + vec4(1, 0, 1, 1);
 	/*#if defined(SPOT_LIGHT)

src/gl/ShaderProgram.cpp

@@ -494,31 +494,47 @@ void ShaderProgram::initUniformBlocks()
 }
 
 //==============================================================================
-const ShaderProgramVariable* ShaderProgram::findVariableByName(
+const ShaderProgramVariable* ShaderProgram::tryFindVariable(
 	const char* name) const
 {
 	NameToVarHashMap::const_iterator it = nameToVar.find(name);
-	if(it == nameToVar.end())
+	return (it == nameToVar.end()) ? nullptr : it->second;
+}
+
+//==============================================================================
+const ShaderProgramVariable& ShaderProgram::findVariable(
+	const char* name) const
+{
+	const ShaderProgramVariable* var = tryFindVariable(name);
+	if(var == nullptr)
 	{
-		return nullptr;
+		throw ANKI_EXCEPTION("Variable not found: " + name);
 	}
-	return it->second;
+	return *var;
 }
 
 //==============================================================================
 const ShaderProgramAttributeVariable*
-	ShaderProgram::findAttributeVariableByName(const char* name) const
+	ShaderProgram::tryFindAttributeVariable(const char* name) const
 {
 	NameToAttribVarHashMap::const_iterator it = nameToAttribVar.find(name);
-	if(it == nameToAttribVar.end())
+	return (it == nameToAttribVar.end()) ? nullptr : it->second;
+}
+
+//==============================================================================
+const ShaderProgramAttributeVariable&
+	ShaderProgram::findAttributeVariable(const char* name) const
+{
+	const ShaderProgramAttributeVariable* var = tryFindAttributeVariable(name);
+	if(var == nullptr)
 	{
-		return nullptr;
+		throw ANKI_EXCEPTION("Attribute variable not found: " + name);
 	}
-	return it->second;
+	return *var;
 }
 
 //==============================================================================
-const ShaderProgramUniformVariable* ShaderProgram::findUniformVariableByName(
+const ShaderProgramUniformVariable* ShaderProgram::tryFindUniformVariable(
 	const char* name) const
 {
 	NameToUniVarHashMap::const_iterator it = nameToUniVar.find(name);
@@ -529,6 +545,18 @@ const ShaderProgramUniformVariable* ShaderProgram::findUniformVariableByName(
 	return it->second;
 }
 
+//==============================================================================
+const ShaderProgramUniformVariable& ShaderProgram::findUniformVariable(
+	const char* name) const
+{
+	const ShaderProgramUniformVariable* var = tryFindUniformVariable(name);
+	if(var == nullptr)
+	{
+		throw ANKI_EXCEPTION("Uniform variable not found: " + name);
+	}
+	return *var;
+}
+
 //==============================================================================
 const ShaderProgramUniformBlock* ShaderProgram::tryFindUniformBlock(
 	const char* name) const

src/renderer/Bl.cpp

@@ -82,9 +82,9 @@ void Bl::runSideBlur()
 	GlStateSingleton::get().enable(GL_BLEND);
 	glBlendFunc(GL_ONE, GL_ONE);
 
-	sideBlurSProg->findUniformVariableByName("tex")->set(
+	sideBlurSProg->findUniformVariable("tex").set(
 		static_cast<const Texture&>(*sideBlurMap));
-	sideBlurSProg->findUniformVariableByName("factor")->set(sideBlurFactor);
+	sideBlurSProg->findUniformVariable("factor").set(sideBlurFactor);
 
 	r->drawQuad();
 }
@@ -96,18 +96,18 @@ void Bl::runBlur()
 
 	// Setup programs here. Reverse order
 	vBlurSProg->bind();
-	vBlurSProg->findUniformVariableByName("img")->set(blurFai);
-	vBlurSProg->findUniformVariableByName("msNormalFai")->set(
+	vBlurSProg->findUniformVariable("img").set(blurFai);
+	vBlurSProg->findUniformVariable("msNormalFai").set(
 		r->getMs().getFai0());
-	vBlurSProg->findUniformVariableByName("imgDimension")->set(
+	vBlurSProg->findUniformVariable("imgDimension").set(
 		float(r->getHeight()));
 
 	hBlurSProg->bind();
-	hBlurSProg->findUniformVariableByName("img")->set(
+	hBlurSProg->findUniformVariable("img").set(
 		r->getPps().getPostPassFai());
-	hBlurSProg->findUniformVariableByName("msNormalFai")->set(
+	hBlurSProg->findUniformVariable("msNormalFai").set(
 		r->getMs().getFai0());
-	hBlurSProg->findUniformVariableByName("imgDimension")->set(
+	hBlurSProg->findUniformVariable("imgDimension").set(
 		float(r->getWidth()));
 
 	for(uint32_t i = 0; i < blurringIterationsNum; i++)

src/renderer/Dbg.cpp

@@ -19,9 +19,13 @@ void Dbg::init(const Renderer::Initializer& initializer)
 	{
 		fbo.create();
 		//fbo.setColorAttachments({&r->getPps().getPostPassFai()});
-		fbo.setColorAttachments({&r->getMs().getFai0()});
+		fbo.setColorAttachments({&r->getIs().getFai()});
 		fbo.setOtherAttachment(GL_DEPTH_ATTACHMENT, r->getMs().getDepthFai());
-		ANKI_ASSERT(fbo.isComplete());
+
+		if(!fbo.isComplete())
+		{
+			throw ANKI_EXCEPTION("FBO is incomplete");
+		}
 	}
 	catch(std::exception& e)
 	{

src/renderer/Deformer.cpp

@@ -46,10 +46,10 @@ void Deformer::deform(SkinNode& skinNode, SkinPatchNode& node) const
 
 	// Uniforms
 	//
-	sProg->findUniformVariableByName("skinningRotations")->set(
+	sProg->findUniformVariable("skinningRotations").set(
 		&skinNode.getBoneRotations()[0], skinNode.getBoneRotations().size());
 
-	sProg->findUniformVariableByName("skinningTranslations")->set(
+	sProg->findUniformVariable("skinningTranslations").set(
 		&skinNode.getBoneTranslations()[0],
 		skinNode.getBoneTranslations().size());
 

src/renderer/Drawer.cpp

@@ -213,7 +213,7 @@ void DebugDrawer::end()
 
 	Mat4 pmv = vpMat * modelMat;
 	sProg->bind();
-	sProg->findUniformVariableByName("modelViewProjectionMat")->set(pmv);
+	sProg->findUniformVariable("modelViewProjectionMat").set(pmv);
 
 	vao.bind();
 	glDrawArrays(GL_LINES, 0, pointIndex);

src/renderer/Hdr.cpp

@@ -82,7 +82,7 @@ void Hdr::run()
 	// pass 0
 	toneFbo.bind();
 	toneSProg.bind();
-	toneSProg.findUniformVariableByName("fai")->set(
+	toneSProg.findUniformVariable("fai").set(
 		r->getPps().getPrePassFai());
 	r->drawQuad();
 
@@ -94,18 +94,18 @@ void Hdr::run()
 		hblurSProg.bind();
 		if(i == 0)
 		{
-			hblurSProg.findUniformVariableByName("img")->set(toneFai);
+			hblurSProg.findUniformVariable("img").set(toneFai);
 		}
 		else if(i == 1)
 		{
-			hblurSProg.findUniformVariableByName("img")->set(fai);
+			hblurSProg.findUniformVariable("img").set(fai);
 		}
 		r->drawQuad();
 
 		// vpass
 		vblurFbo.bind();
 		vblurSProg.bind();
-		vblurSProg.findUniformVariableByName("img")->set(hblurFai);
+		vblurSProg.findUniformVariable("img").set(hblurFai);
 		r->drawQuad();
 	}
 }

src/renderer/Is.cpp

@@ -1,23 +1,27 @@
 #include "anki/renderer/Is.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/scene/Scene.h"
+#include "anki/scene/Camera.h"
+#include "anki/scene/Light.h"
 
-#define BLEND_ENABLE true
+#define BLEND_ENABLE 0
 
 namespace anki {
 
+//==============================================================================
+
 /// Representation of the program's block
 struct UniformBlockData
 {
-	vec2 planes;
-	vec2 limitsOfNearPlane;
-	vec2 limitsOfNearPlane2;
-	float zNear; float padding0;
-	float lightRadius; float padding1;
-	float shadowMapSize; float padding2;
-	vec3 lightPos; float padding3;
-	vec3 lightDiffuseCol; float padding4;
-	vec3 lightSpecularCol; float padding5;
-	mat4 texProjectionMat;
+	Vec2 planes;
+	Vec2 limitsOfNearPlane;
+	Vec2 limitsOfNearPlane2;
+	float zNear; float lightRadius;
+	float shadowMapSize; float padding0;
+	Vec3 lightPos; float padding1;
+	Vec4 lightDiffuseCol;
+	Vec4 lightSpecularCol;
+	Mat4 texProjectionMat;
 };
 
 //==============================================================================
@@ -65,8 +69,10 @@ void Is::init(const RendererInitializer& /*initializer*/)
 
 		// Create FBO
 		//
+		Renderer::createFai(r->getWidth(), r->getHeight(), GL_RGB8,
+			GL_RGB, GL_UNSIGNED_INT, fai);
 		fbo.create();
-		fbo.setColorAttachments({fai});
+		fbo.setColorAttachments({&fai});
 
 		if(!fbo.isComplete())
 		{
@@ -83,7 +89,8 @@ void Is::init(const RendererInitializer& /*initializer*/)
 			throw ANKI_EXCEPTION("Uniform block size is not the expected");
 		}
 
-		ubo.create(GL_UNIFORM_BUFFER, blockSize, nullptr, GL_STATIC_DRAW);
+		ubo.create(GL_UNIFORM_BUFFER, sizeof(UniformBlockData), nullptr,
+			GL_DYNAMIC_DRAW);
 
 		ubo.setBinding(0);
 	}
@@ -93,28 +100,46 @@ void Is::init(const RendererInitializer& /*initializer*/)
 	}
 }
 
+//==============================================================================
+void Is::ambientPass(const Vec3& color)
+{
+	GlStateSingleton::get().disable(GL_BLEND);
+
+	// set the shader
+	ambientPassSProg->bind();
+
+	// set the uniforms
+	ambientPassSProg->findUniformVariable("ambientCol").set(color);
+	ambientPassSProg->findUniformVariable("msFai0").set(
+		r->getMs().getFai0());
+
+	// Draw quad
+	r->drawQuad();
+}
+
 //==============================================================================
 void Is::pointLightPass(PointLight& light)
 {
-	const Camera& cam = r.getCamera();
+	const Camera& cam = r->getScene().getActiveCamera();
 
 	// XXX SMO
-	GlStateSingleton::get().enable(GL_DEPTH_TEST, false);
+	GlStateSingleton::get().disable(GL_DEPTH_TEST);
 
 	// shader prog
 	const ShaderProgram& shader = *pointLightSProg; // ensure the const-ness
 	shader.bind();
 
-	shader.findUniformVariableByName("msFai0")->set(r->getMs().getFai0());
-	shader.findUniformVariableByName("msDepthFai")->set(
+	shader.findUniformVariable("msFai0").set(r->getMs().getFai0());
+	shader.findUniformVariable("msDepthFai").set(
 		r->getMs().getDepthFai());
 
 	UniformBlockData data;
 	data.planes = r->getPlanes();
-	data.limitsOfNearPlane = r->.getLimitsOfNearPlane();
-	data.limitsOfNearPlane2 = r->getLimitsOfNearPlane();
-	data.zNear = cam.getZNear();
-	Vec3 lightPosEyeSpace = origin.getTransformed(cam.getViewMatrix());
+	data.limitsOfNearPlane = r->getLimitsOfNearPlane();
+	data.limitsOfNearPlane2 = r->getLimitsOfNearPlane2();
+	data.zNear = cam.getNear();
+	Vec3 lightPosEyeSpace = light.getWorldTransform().getOrigin().
+		getTransformed(cam.getViewMatrix());
 	data.lightPos = lightPosEyeSpace;
 	data.lightRadius = light.getRadius();
 	data.lightDiffuseCol = light.getDiffuseColor();
@@ -129,7 +154,39 @@ void Is::pointLightPass(PointLight& light)
 //==============================================================================
 void Is::run()
 {
-	/// TODO
+	GlStateSingleton::get().setViewport(0, 0, r->getWidth(), r->getHeight());
+	fbo.bind();
+
+	GlStateSingleton::get().disable(GL_DEPTH_TEST);
+
+	// Ambient pass
+	ambientPass(r->getScene().getAmbientColor());
+
+	// render lights
+#if BLEND_ENABLE
+	GlStateSingleton::get().enable(GL_BLEND);
+	glBlendFunc(GL_ONE, GL_ONE);
+#endif
+
+	VisibilityInfo& vi = r->getScene().getVisibilityInfo();
+	for(auto it = vi.getLightsBegin();
+		it != vi.getLightsEnd(); ++it)
+	{
+		Light& light = *(*it);
+		switch(light.getLightType())
+		{
+		case Light::LT_SPOT:
+			break;
+		case Light::LT_POINT:
+			pointLightPass(static_cast<PointLight&>(light));
+			break;
+		default:
+			ANKI_ASSERT(0);
+			break;
+		}
+	}
+
+	GlStateSingleton::get().enable(GL_DEPTH_TEST);
 }
 
 } // end namespace anki

src/renderer/MainRenderer.cpp

@@ -112,8 +112,8 @@ void MainRenderer::render(Scene& scene)
 	GlStateSingleton::get().disable(GL_DEPTH_TEST);
 	GlStateSingleton::get().disable(GL_BLEND);
 	sProg->bind();
-	const Texture& finalFai = ms.getFai0();
-	sProg->findUniformVariableByName("rasterImage")->set(finalFai);
+	const Texture& finalFai = is.getFai();//ms.getFai0();
+	sProg->findUniformVariable("rasterImage").set(finalFai);
 	drawQuad();
 }
 

src/renderer/Ms.cpp

@@ -58,6 +58,7 @@ void Ms::run()
 	}*/
 
 	GlStateSingleton::get().setViewport(0, 0, r->getWidth(), r->getHeight());
+	GlStateSingleton::get().disable(GL_BLEND);
 
 	//GlStateMachineSingleton::get().enable(GL_DEPTH_TEST, true);
 	//app->getScene().skybox.Render(cam.getViewMatrix().getRotationPart());

src/renderer/Pps.cpp

@@ -97,11 +97,11 @@ void Pps::runPrePass()
 		r->getWidth(), r->getHeight());
 
 	prePassSProg.bind();
-	prePassSProg.findUniformVariableByName("isFai")->set(r->getIs().getFai());
+	prePassSProg.findUniformVariable("isFai").set(r->getIs().getFai());
 
 	if(ssao.getEnabled())
 	{
-		prePassSProg.findUniformVariableByName("ppsSsaoFai")->set(
+		prePassSProg.findUniformVariable("ppsSsaoFai").set(
 			ssao.getFai());
 	}
 
@@ -125,11 +125,11 @@ void Pps::runPostPass()
 	GlStateSingleton::get().setViewport(0, 0, r->getWidth(), r->getHeight());
 
 	postPassSProg.bind();
-	postPassSProg.findUniformVariableByName("ppsPrePassFai")->set(prePassFai);
+	postPassSProg.findUniformVariable("ppsPrePassFai").set(prePassFai);
 
 	if(hdr.getEnabled())
 	{
-		postPassSProg.findUniformVariableByName("ppsHdrFai")->set(hdr.getFai());
+		postPassSProg.findUniformVariable("ppsHdrFai").set(hdr.getFai());
 	}
 
 	r->drawQuad();

src/renderer/Renderer.cpp

@@ -108,8 +108,8 @@ void Renderer::render(Scene& scene_)
 	else
 	{
 		ms.run();
-		/*is.run();
-		pps.runPrePass();
+		is.run();
+		/*pps.runPrePass();
 		bs.run();
 		pps.runPostPass();*/
 	}

src/renderer/Ssao.cpp

@@ -87,42 +87,42 @@ void Ssao::run()
 	ssaoSProg.bind();
 	
 	// planes
-	ssaoSProg.findUniformVariableByName("planes")->set(r->getPlanes());
+	ssaoSProg.findUniformVariable("planes").set(r->getPlanes());
 
 	// limitsOfNearPlane
-	ssaoSProg.findUniformVariableByName("limitsOfNearPlane")->set(
+	ssaoSProg.findUniformVariable("limitsOfNearPlane").set(
 		r->getLimitsOfNearPlane());
 
 	// limitsOfNearPlane2
-	ssaoSProg.findUniformVariableByName("limitsOfNearPlane2")->set(
+	ssaoSProg.findUniformVariable("limitsOfNearPlane2").set(
 		r->getLimitsOfNearPlane2());
 
 	// zNear
-	ssaoSProg.findUniformVariableByName("zNear")->set(cam.getNear());
+	ssaoSProg.findUniformVariable("zNear").set(cam.getNear());
 
 	// msDepthFai
-	ssaoSProg.findUniformVariableByName("msDepthFai")->set(
+	ssaoSProg.findUniformVariable("msDepthFai").set(
 		r->getMs().getDepthFai());
 
 	// noiseMap
-	ssaoSProg.findUniformVariableByName("noiseMap")->set(*noiseMap);
+	ssaoSProg.findUniformVariable("noiseMap").set(*noiseMap);
 
 	// noiseMapSize
-	ssaoSProg.findUniformVariableByName("noiseMapSize")->set(
+	ssaoSProg.findUniformVariable("noiseMapSize").set(
 		noiseMap->getWidth());
 
 	// screenSize
 	Vec2 screenSize(width * 2, height * 2);
-	ssaoSProg.findUniformVariableByName("screenSize")->set(screenSize);
+	ssaoSProg.findUniformVariable("screenSize").set(screenSize);
 
 	// msNormalFai
-	ssaoSProg.findUniformVariableByName("msNormalFai")->set(
+	ssaoSProg.findUniformVariable("msNormalFai").set(
 		r->getMs().getFai0());
 
 	r->drawQuad();
 
 	vblurSProg.bind();
-	vblurSProg.findUniformVariableByName("img")->set(hblurFai);
+	vblurSProg.findUniformVariable("img").set(hblurFai);
 
 	// Blurring passes
 	//
@@ -133,11 +133,11 @@ void Ssao::run()
 		hblurSProg.bind();
 		if(i == 0)
 		{
-			hblurSProg.findUniformVariableByName("img")->set(ssaoFai);
+			hblurSProg.findUniformVariable("img").set(ssaoFai);
 		}
 		else if(i == 1)
 		{
-			hblurSProg.findUniformVariableByName("img")->set(fai);
+			hblurSProg.findUniformVariable("img").set(fai);
 		}
 		r->drawQuad();
 

src/resource/Material.cpp

@@ -48,7 +48,7 @@ void MaterialVariable::init(const char* shaderProgVarName,
 
 		// Variable exists put it the map
 		const ShaderProgramUniformVariable* uni = 
-			sProg.findUniformVariableByName(shaderProgVarName);
+			sProg.tryFindUniformVariable(shaderProgVarName);
 		if(uni)
 		{
 			sProgVars[key] = uni;

src/resource/Model.cpp

@@ -25,7 +25,7 @@ Vao* ModelPatchBase::createNewVao(const Material& mtl,
 	const ShaderProgramAttributeVariable* attrib;
 	const ShaderProgram& prog = mtl.findShaderProgram(key);
 
-	attrib = prog.findAttributeVariableByName("position");
+	attrib = prog.tryFindAttributeVariable("position");
 	if(attrib)
 	{
 		const Vbo* vbo = meshb.getVbo(Mesh::VBO_POSITIONS);
@@ -35,7 +35,7 @@ Vao* ModelPatchBase::createNewVao(const Material& mtl,
 			nullptr);
 	}
 
-	attrib = prog.findAttributeVariableByName("normal");
+	attrib = prog.tryFindAttributeVariable("normal");
 	if(attrib)
 	{
 		const Vbo* vbo = meshb.getVbo(Mesh::VBO_NORMALS);
@@ -45,7 +45,7 @@ Vao* ModelPatchBase::createNewVao(const Material& mtl,
 			nullptr);
 	}
 
-	attrib = prog.findAttributeVariableByName("tangent");
+	attrib = prog.tryFindAttributeVariable("tangent");
 	if(attrib)
 	{
 		const Vbo* vbo = meshb.getVbo(Mesh::VBO_TANGENTS);
@@ -55,7 +55,7 @@ Vao* ModelPatchBase::createNewVao(const Material& mtl,
 			nullptr);
 	}
 
-	attrib = prog.findAttributeVariableByName("texCoords");
+	attrib = prog.tryFindAttributeVariable("texCoords");
 	if(attrib)
 	{
 		const Vbo* vbo = meshb.getVbo(Mesh::VBO_TEX_COORDS);

src/ui/UiPainter.cpp

@@ -36,8 +36,8 @@ void UiPainter::init()
 	// SProg
 	sProg.load("shaders/UiText.glsl");
 	sProg->bind();
-	sProg->findUniformVariableByName("texture")->set(font->getMap());
-	sProg->findUniformVariableByName("color")->set(col);
+	sProg->findUniformVariable("texture").set(font->getMap());
+	sProg->findUniformVariable("color").set(col);
 
 	// Geom
 	float quadVertCoords[][2] = {{1.0, 1.0}, {0.0, 1.0}, {0.0, 0.0},
@@ -65,7 +65,7 @@ void UiPainter::drawText(const char* text)
 
 	// SProg (some)
 	sProg->bind();
-	sProg->findUniformVariableByName("texture")->set(font->getMap());
+	sProg->findUniformVariable("texture").set(font->getMap());
 
 	// Vao
 	qVao.bind();
@@ -105,8 +105,8 @@ void UiPainter::drawText(const char* text)
 			trfM(1, 2) = p.y() + 2.0 * (font->getGlyphBearingY(cc) -
 				int(font->getGlyphHeight(cc))) / deviceSize.y();
 
-			sProg->findUniformVariableByName("transformation")->set(trfM);
-			sProg->findUniformVariableByName("textureTranformation")->set(
+			sProg->findUniformVariable("transformation").set(trfM);
+			sProg->findUniformVariable("textureTranformation").set(
 				font->getGlyphTextureMatrix(cc));
 
 			// Render

testapp/Main.cpp

@@ -80,12 +80,18 @@ void init()
 	spot->setFov(Math::toRad(45.0));
 	spot->setLocalTransform(Transform(Vec3(1.3, 4.3, 3.0),
 		Mat3(Euler(Math::toRad(-20), Math::toRad(20), 0.0)), 1.0));
-	spot->setColor(Vec4(4.0));
+	spot->setDiffuseColor(Vec4(4.0));
 	spot->setSpecularColor(Vec4(1.0));
 	spot->loadTexture("gfx/lights/flashlight.tga");
 	spot->setDistance(20.0);
 	spot->setShadowEnabled(true);
 
+	PointLight* point = new PointLight("point0", &scene, Movable::MF_NONE,
+		nullptr);
+	point->setRadius(3.0);
+	point->setDiffuseColor(Vec4(1.0, 0.0, 0.0, 0.0));
+	point->setSpecularColor(Vec4(0.0, 0.0, 1.0, 0.0));
+
 	// horse
 	horse = new ModelNode("meshes/horse/horse.mdl", "horse", &scene,
 		Movable::MF_NONE, nullptr);
@@ -119,6 +125,10 @@ void mainLoopExtra()
 	{
 		mover = SceneSingleton::get().findSceneNode("spot0")->getMovable();
 	}
+	if(in.getKey(SDL_SCANCODE_4))
+	{
+		mover = SceneSingleton::get().findSceneNode("point0")->getMovable();
+	}
 
 	if(in.getKey(SDL_SCANCODE_UP)) mover->rotateLocalX(ang);
 	if(in.getKey(SDL_SCANCODE_DOWN)) mover->rotateLocalX(-ang);
@@ -216,7 +226,7 @@ void main()
 		glDisable(GL_DEPTH_TEST);*/
 
 		sprog.bind();
-		sprog.findUniformVariableByName("mvp")->set(
+		sprog.findUniformVariable("mvp").set(
 			cam->getProjectionMatrix() * cam->getViewMatrix());
 		//horse->model->getModelPatches()[0].getVao(PassLevelKey(0, 0)).bind();
 		vao.bind();