# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1346294100 -10800
# Node ID acfe0c0110fce047008305a27342117605ef5c93
# Parent  38e16366efc2fabc88254dbb3e33911b9f4553a4
- cleaned up the renderer
- implemented fallback (non-deferred renderer)

diff -r 38e16366efc2 -r acfe0c0110fc prototype/sdr/fallback.p.glsl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/prototype/sdr/fallback.p.glsl	Thu Aug 30 05:35:00 2012 +0300
@@ -0,0 +1,38 @@
+uniform sampler2D tex_dif, tex_norm;
+
+varying vec3 pos, norm, tang;
+
+const float fog_start = 3.0;
+const float fog_end = 6.0;
+
+void main()
+{
+	vec3 texel = texture2D(tex_dif, gl_TexCoord[0].st).xyz;
+
+	vec3 n = normalize(norm);
+	vec3 t = normalize(tang);
+	vec3 b = cross(n, t);
+
+	mat3 tbn_mat = mat3(
+			t.x, b.x, n.x,
+			t.y, b.y, n.y,
+			t.z, b.z, n.z);
+
+
+	const vec3 lpos = vec3(0.0, 0.0, -0.5);
+	vec3 ldir = tbn_mat * normalize(lpos - pos);
+
+	const vec3 vdir = vec3(0.0, 0.0, 1.0);
+	vec3 hvec = normalize(vdir + ldir);
+
+	n = normalize(texture2D(tex_norm, gl_TexCoord[0].st).xyz * 2.0 - 1.0);
+	float ndotl = max(dot(n, ldir), 0.0);
+	float ndoth = max(dot(n, hvec), 0.0);
+
+	vec3 diffuse = gl_FrontMaterial.diffuse.xyz * texel * ndotl;
+	vec3 specular = gl_FrontMaterial.specular.xyz * pow(ndoth, gl_FrontMaterial.shininess);
+
+	float fog = clamp((fog_end + pos.z) / (fog_end - fog_start), 0.0, 1.0);
+
+	gl_FragColor = vec4((diffuse + specular) * fog, 1.0);
+}
diff -r 38e16366efc2 -r acfe0c0110fc prototype/sdr/fallback.v.glsl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/prototype/sdr/fallback.v.glsl	Thu Aug 30 05:35:00 2012 +0300
@@ -0,0 +1,13 @@
+attribute vec3 attr_tangent;
+
+varying vec3 pos, norm, tang;
+
+void main()
+{
+	gl_Position = ftransform();
+	pos = (gl_ModelViewMatrix * gl_Vertex).xyz;
+	norm = gl_NormalMatrix * gl_Normal;
+	tang = gl_NormalMatrix * attr_tangent;
+
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/light.cc
--- a/prototype/src/light.cc	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/light.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -114,7 +114,7 @@
 
 void PointLight::draw() const
 {
-	unsigned int sdr = get_deferred_shader();
+	unsigned int sdr = rend->get_current_program();
 	if(sdr) {
 		int loc;
 		if((loc = glGetUniformLocation(sdr, "light_radius")) != -1) {
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/main.cc
--- a/prototype/src/main.cc	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/main.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -8,6 +8,7 @@
 #include "datapath.h"
 #include "tileset.h"
 #include "renderer.h"
+#include "renderer_deferred.h"
 #include "cmdcon.h"
 #include "cfg.h"
 #include "timer.h"
@@ -70,11 +71,15 @@
 
 bool init(int xsz, int ysz)
 {
+	// backup light for the forward crappy renderer
 	glEnable(GL_LIGHTING);
 	glEnable(GL_LIGHT0);
-	float ldir[] = {-1, 1, 2, 0};
+
+	float ldir[] = {0, 0, -0.5, 1};
 	glLightfv(GL_LIGHT0, GL_POSITION, ldir);
-	glEnable(GL_NORMALIZE);
+	float lcol[] = {1, 1, 1, 1};
+	glLightfv(GL_LIGHT0, GL_DIFFUSE, lcol);
+	glLightfv(GL_LIGHT0, GL_SPECULAR, lcol);
 
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_CULL_FACE);
@@ -84,8 +89,15 @@
 	add_data_path("data");
 	add_data_path("sdr");
 
-	if(!init_renderer(xsz, ysz)) {
-		return false;
+	rend = new DeferredRenderer();
+	if(!rend->init(xsz, ysz)) {
+		printf("falling back to crappy renderer...\n");
+
+		rend = new FwdRenderer();
+		if(!rend->init(xsz, ysz)) {
+			fprintf(stderr, "failed to create renderer\n");
+			return false;
+		}
 	}
 
 	if(!init_cmdcon()) {
@@ -115,8 +127,7 @@
 {
 	delete level;
 	delete tileset;
-
-	destroy_renderer();
+	delete rend;
 
 	cleanup_cmdcon();
 }
@@ -165,15 +176,13 @@
 
 	glutSwapBuffers();
 	assert(glGetError() == GL_NO_ERROR);
-
-	usleep(10000);
 }
 
 void draw()
 {
-	glClear(GL_COLOR_BUFFER_BIT);
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-	render_deferred(level);
+	rend->render(level);
 
 	if(show_con) {
 		draw_cmdcon();
@@ -240,7 +249,7 @@
 	cfg.width = x;
 	cfg.height = y;
 
-	resize_renderer(x, y);
+	rend->resize(x, y);
 }
 
 static bool stereo_shift_pressed;
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/material.cc
--- a/prototype/src/material.cc	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/material.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -3,6 +3,7 @@
 #include <assimp/material.h>
 #include "opengl.h"
 #include "material.h"
+#include "renderer.h"
 
 extern bool ass_obj_hack;
 
@@ -74,7 +75,7 @@
 		glDisable(GL_TEXTURE_2D);
 	}
 
-	if(tex[TEXTYPE_NORMAL]) {
+	if(rend->get_current_program() && tex[TEXTYPE_NORMAL]) {
 		glActiveTextureARB(GL_TEXTURE1);
 		glBindTexture(GL_TEXTURE_2D, tex[TEXTYPE_NORMAL]);
 		glEnable(GL_TEXTURE_2D);
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/renderer.cc
--- a/prototype/src/renderer.cc	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/renderer.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -1,247 +1,97 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <assert.h>
 #include "opengl.h"
 #include "renderer.h"
 #include "level.h"
 #include "sdr.h"
 #include "datapath.h"
 
-#undef DBG_VIS_MRT
+static unsigned int load_sdr(const char *vfname, const char *pfname);
 
-#ifdef DBG_VIS_MRT
-static void draw_deferred_debug();
-#endif
+Renderer *rend;
 
-static bool create_fbo(int xsz, int ysz);
-static unsigned int load_sdr(const char *vfname, const char *pfname);
-static int round_pow2(int x);
 
+Renderer::Renderer()
+{
+	width = height = 0;
+}
 
-#define MRT_COUNT	3
-static unsigned int mrt_tex[MRT_COUNT];
+Renderer::~Renderer()
+{
+}
 
-static unsigned int mrt_prog;
-static unsigned int deferred_omni, deferred_debug;
+bool Renderer::init(int xsz, int ysz)
+{
+	width = xsz;
+	height = ysz;
 
-static unsigned int fbo, rbuf_depth;
-static const char *fbstname[] = {
-	"GL_FRAMEBUFFER_COMPLETE",
-	"GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
-	"GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
-	"no such fbo error",
-	"GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
-	"GL_FRAMEBUFFER_INCOMPLETE_FORMATS",
-	"GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",
-	"GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",
-	"GL_FRAMEBUFFER_UNSUPPORTED"
-};
+	rend = this;
+	return true;
+}
 
-static int fb_xsz, fb_ysz, tex_xsz, tex_ysz;
+int Renderer::get_tangent_location() const
+{
+	return -1;
+}
 
+unsigned int Renderer::get_current_program() const
+{
+	return 0;
+}
 
+void Renderer::resize(int xsz, int ysz)
+{
+	width = xsz;
+	height = ysz;
+}
 
-bool init_renderer(int xsz, int ysz)
+
+// ---- fallback forward renderer ----
+FwdRenderer::FwdRenderer()
 {
-	if(!GLEW_ARB_texture_float) {
-		fprintf(stderr, "Error: OpenGL implementation doesn't support floating point textures\n");
-		return false;
+	sdrprog = 0;
+	tang_attr = -1;
+}
+
+FwdRenderer::~FwdRenderer()
+{
+	if(sdrprog) {
+		free_program(sdrprog);
 	}
-	if(!GLEW_ARB_draw_buffers) {
-		fprintf(stderr, "Error: OpenGL implementation doesn't support multiple render targets\n");
-		return false;
-	}
+}
 
-	int max_draw_buf;
-	glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buf);
-	printf("max draw buffers: %d\n", max_draw_buf);
-	if(max_draw_buf < MRT_COUNT) {
-		fprintf(stderr, "OpenGL implementation doesn't support enough draw buffers\n");
-		return false;
-	}
+bool FwdRenderer::init(int xsz, int ysz)
+{
+	width = xsz;
+	height = ysz;
 
-	if(!create_fbo(xsz, ysz)) {
-		return false;
-	}
-	CHECKGLERR;
-
-	if(!(mrt_prog = load_sdr("mrt.v.glsl", "mrt.p.glsl"))) {
-		return false;
-	}
-	set_uniform_int(mrt_prog, "tex_dif", 0);
-	set_uniform_int(mrt_prog, "tex_norm", 1);
-
-	if(!(deferred_debug = load_sdr("deferred.v.glsl", "deferred.p.glsl"))) {
-		return false;
-	}
-	for(int i=0; i<MRT_COUNT; i++) {
-		char uname[32];
-		sprintf(uname, "mrt%d", i);
-		set_uniform_int(deferred_debug, uname, i);
-	}
-
-	if(!(deferred_omni = load_sdr("deferred_omni.v.glsl", "deferred_omni.p.glsl"))) {
-		return false;
-	}
-	for(int i=0; i<MRT_COUNT; i++) {
-		char uname[32];
-		sprintf(uname, "mrt%d", i);
-		set_uniform_int(deferred_omni, uname, i);
+	if(glUseProgram && (sdrprog = load_sdr("fallback.v.glsl", "fallback.p.glsl"))) {
+		tang_attr = get_attrib_loc(sdrprog, "attr_tangent");
+		set_uniform_int(sdrprog, "tex_dif", 0);
+		set_uniform_int(sdrprog, "tex_norm", 1);
 	}
 	return true;
 }
 
-void destroy_renderer()
+int FwdRenderer::get_tangent_location() const
 {
-	free_program(mrt_prog);
-	free_program(deferred_omni);
-
-	glDeleteTextures(MRT_COUNT, mrt_tex);
-	glDeleteFramebuffersEXT(1, &fbo);
+	return tang_attr;
 }
 
-unsigned int get_deferred_shader(void)
+unsigned int FwdRenderer::get_current_program() const
 {
-	return deferred_omni;
+	return sdrprog;
 }
 
-int get_tangent_location(void)
+void FwdRenderer::render(const Level *level) const
 {
-	return get_attrib_loc(mrt_prog, "attr_tangent");
-}
+	glPushAttrib(GL_ENABLE_BIT);
+	glUseProgram(sdrprog);
 
-void resize_renderer(int xsz, int ysz)
-{
-	fb_xsz = xsz;
-	fb_ysz = ysz;
-
-	// if we need a bigger rendertarget resize all colorbuffer textures and the depth buffer
-	if(xsz > tex_xsz || ysz > tex_ysz) {
-		tex_xsz = round_pow2(xsz);
-		tex_ysz = round_pow2(ysz);
-
-		for(int i=0; i<MRT_COUNT; i++) {
-			glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);
-		}
-
-		glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);
-		glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);
-	}
-
-
-	// update the texture coordinate scaling factors
-	float tex_scale_x = (float)fb_xsz / tex_xsz;
-	float tex_scale_y = (float)fb_ysz / tex_ysz;
-
-	set_uniform_float2(deferred_omni, "tex_scale", tex_scale_x, tex_scale_y);
-	set_uniform_float2(deferred_omni, "fb_size", fb_xsz, fb_ysz);
-
-	set_uniform_float2(deferred_debug, "tex_scale", tex_scale_x, tex_scale_y);
-}
-
-void render_deferred(const Level *level)
-{
-	// render into the MRT buffers
-	glUseProgram(mrt_prog);
-	glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glEnable(GL_LIGHTING);
 	level->draw();
 
-	glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
-
-#ifdef DBG_VIS_MRT
-	draw_deferred_debug();
-#else
-
-	// post-process lighting
-	glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
-
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_ONE, GL_ONE);
-
-	glDisable(GL_LIGHTING);
-	glDisable(GL_DEPTH_TEST);
-	glCullFace(GL_FRONT);
-
-	glUseProgram(deferred_omni);
-	for(int i=0; i<MRT_COUNT; i++) {
-		glActiveTexture(GL_TEXTURE0 + i);
-		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
-		glEnable(GL_TEXTURE_2D);
-	}
-
-	glDepthMask(0);
-	level->draw_lights();
-	glDepthMask(1);
-
-	for(int i=0; i<MRT_COUNT; i++) {
-		glActiveTexture(GL_TEXTURE0 + MRT_COUNT - i - 1);
-		glDisable(GL_TEXTURE_2D);
-	}
+	glPopAttrib();
 
 	glUseProgram(0);
-	glPopAttrib();
-#endif	// DBG_VIS_MRT
-}
-
-static bool create_fbo(int xsz, int ysz)
-{
-	unsigned int clamp = GLEW_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;
-
-	// round the texture size up to the next power of 2
-	tex_xsz = round_pow2(xsz);
-	tex_ysz = round_pow2(ysz);
-	fb_xsz = xsz;
-	fb_ysz = ysz;
-
-	if(!glGenFramebuffersEXT) {
-		fprintf(stderr, "FBO support missing\n");
-		return false;
-	}
-	glGenFramebuffersEXT(1, &fbo);
-	glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
-
-	glGenTextures(MRT_COUNT, mrt_tex);
-	for(int i=0; i<MRT_COUNT; i++) {
-		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);
-
-		// attach to fbo
-		glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
-				GL_TEXTURE_2D, mrt_tex[i], 0);
-		CHECKGLERR;
-	}
-
-	static GLenum draw_bufs[] = {
-		GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,
-		GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,
-		GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,
-		GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT
-	};
-	glDrawBuffersARB(MRT_COUNT, draw_bufs);
-
-	glGenRenderbuffersEXT(1, &rbuf_depth);
-	glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);
-	glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);
-	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbuf_depth);
-
-	int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
-	if(fbst != GL_FRAMEBUFFER_COMPLETE) {
-		fprintf(stderr, "incomplete fbo: %u (%s)\n", fbo, fbstname[fbst - GL_FRAMEBUFFER_COMPLETE]);
-		return false;
-	}
-	CHECKGLERR;
-
-	glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
-	return true;
 }
 
 static unsigned int load_sdr(const char *vfname, const char *pfname)
@@ -266,61 +116,3 @@
 	}
 	return prog;
 }
-
-static int round_pow2(int x)
-{
-	x--;
-	x = (x >> 1) | x;
-	x = (x >> 2) | x;
-	x = (x >> 4) | x;
-	x = (x >> 8) | x;
-	x = (x >> 16) | x;
-	return x + 1;
-}
-
-#ifdef DBG_VIS_MRT
-// visualize the MRT buffers
-static void draw_deferred_debug()
-{
-	glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
-	glUseProgram(deferred_debug);
-	glDisable(GL_DEPTH_TEST);
-
-	glMatrixMode(GL_PROJECTION);
-	glPushMatrix();
-	glLoadIdentity();
-	glMatrixMode(GL_MODELVIEW);
-	glPushMatrix();
-	glLoadIdentity();
-
-	for(int i=0; i<MRT_COUNT; i++) {
-		glActiveTexture(GL_TEXTURE0 + i);
-		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
-		glEnable(GL_TEXTURE_2D);
-	}
-
-	glBegin(GL_QUADS);
-	glTexCoord2f(0, 0);
-	glVertex2f(-1, -1);
-	glTexCoord2f(1, 0);
-	glVertex2f(1, -1);
-	glTexCoord2f(1, 1);
-	glVertex2f(1, 1);
-	glTexCoord2f(0, 1);
-	glVertex2f(-1, 1);
-	glEnd();
-
-	for(int i=0; i<MRT_COUNT; i++) {
-		glActiveTexture(GL_TEXTURE0 + MRT_COUNT - i - 1);
-		glDisable(GL_TEXTURE_2D);
-	}
-
-	glMatrixMode(GL_PROJECTION);
-	glPopMatrix();
-	glMatrixMode(GL_MODELVIEW);
-	glPopMatrix();
-
-	glUseProgram(0);
-	glPopAttrib();
-}
-#endif
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/renderer.h
--- a/prototype/src/renderer.h	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/renderer.h	Thu Aug 30 05:35:00 2012 +0300
@@ -3,15 +3,44 @@
 
 class Level;
 
-bool init_renderer(int xsz, int ysz);
-void destroy_renderer();
+class Renderer {
+protected:
+	int width, height;
 
-unsigned int get_deferred_shader(void);
-int get_tangent_location(void);
+public:
+	Renderer();
+	virtual ~Renderer();
 
-void resize_renderer(int xsz, int ysz);
+	virtual bool init(int xsz, int ysz);
 
-void update_renderer(unsigned long msec, float dt);
-void render_deferred(const Level *level);
+	virtual int get_tangent_location() const;
+	virtual unsigned int get_current_program() const;
+
+	virtual void resize(int xsz, int ysz);
+
+	virtual void render(const Level *level) const = 0;
+};
+
+
+class FwdRenderer : public Renderer {
+protected:
+	unsigned int sdrprog;
+	int tang_attr;
+
+public:
+	FwdRenderer();
+	~FwdRenderer();
+
+	bool init(int xsz, int ysz);
+
+	int get_tangent_location() const;
+	unsigned int get_current_program() const;
+
+	void render(const Level *level) const;
+};
+
+
+extern Renderer *rend;
+
 
 #endif	// RENDERER_H_
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/renderer_deferred.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/prototype/src/renderer_deferred.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -0,0 +1,322 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "opengl.h"
+#include "renderer_deferred.h"
+#include "level.h"
+#include "sdr.h"
+#include "datapath.h"
+
+static unsigned int load_sdr(const char *vfname, const char *pfname);
+static int round_pow2(int x);
+
+DeferredRenderer::DeferredRenderer()
+{
+	fbo = rbuf_depth = 0;
+	for(int i=0; i<MRT_COUNT; i++) {
+		mrt_tex[i] = 0;
+	}
+	tex_xsz = tex_ysz = 0;
+
+	mrt_prog = deferred_debug = deferred_omni = 0;
+
+	curr_prog = 0;
+}
+
+DeferredRenderer::~DeferredRenderer()
+{
+	if(mrt_prog) {
+		free_program(mrt_prog);
+	}
+	if(deferred_omni) {
+		free_program(deferred_omni);
+	}
+	if(deferred_debug) {
+		free_program(deferred_debug);
+	}
+
+	if(mrt_tex[0]) {
+		glDeleteTextures(MRT_COUNT, mrt_tex);
+	}
+	if(fbo) {
+		glDeleteFramebuffersEXT(1, &fbo);
+	}
+}
+
+bool DeferredRenderer::init(int xsz, int ysz)
+{
+	width = xsz;
+	height = ysz;
+
+	if(!GLEW_ARB_texture_float) {
+		fprintf(stderr, "%s: error: no floating point texture support\n", __func__);
+		return false;
+	}
+	if(!GLEW_ARB_draw_buffers) {
+		fprintf(stderr, "%s: error: no multiple render target support\n", __func__);
+		return false;
+	}
+
+	int max_draw_buf;
+	glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buf);
+	printf("max draw buffers: %d\n", max_draw_buf);
+	if(max_draw_buf < MRT_COUNT) {
+		fprintf(stderr, "%s: error: not enough draw buffers (%d), %d required\n", __func__, max_draw_buf, MRT_COUNT);
+		return false;
+	}
+
+	if(!create_fbo()) {
+		return false;
+	}
+
+	if(!(mrt_prog = load_sdr("mrt.v.glsl", "mrt.p.glsl"))) {
+		return false;
+	}
+	set_uniform_int(mrt_prog, "tex_dif", 0);
+	set_uniform_int(mrt_prog, "tex_norm", 1);
+
+	if(!(deferred_omni = load_sdr("deferred_omni.v.glsl", "deferred_omni.p.glsl"))) {
+		return false;
+	}
+	for(int i=0; i<MRT_COUNT; i++) {
+		char uname[32];
+		sprintf(uname, "mrt%d", i);
+		set_uniform_int(deferred_omni, uname, i);
+	}
+
+	rend = this;
+	return true;
+}
+
+int DeferredRenderer::get_tangent_location() const
+{
+	return get_attrib_loc(mrt_prog, "attr_tangent");
+}
+
+unsigned int DeferredRenderer::get_current_program() const
+{
+	return curr_prog;
+}
+
+void DeferredRenderer::resize(int xsz, int ysz)
+{
+	width = xsz;
+	height = ysz;
+
+	// if we need a bigger rendertarget ...
+	if(xsz > tex_xsz || ysz > tex_ysz) {
+		tex_xsz = round_pow2(xsz);
+		tex_ysz = round_pow2(ysz);
+
+		// ... resize all the color buffers
+		for(int i=0; i<MRT_COUNT; i++) {
+			glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);
+		}
+
+		// ... resize the depth buffer
+		glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);
+		glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);
+	}
+
+	// update the texture coordinate scaling factors
+	float tex_scale_x = (float)width / tex_xsz;
+	float tex_scale_y = (float)height / tex_ysz;
+
+	set_uniform_float2(deferred_omni, "tex_scale", tex_scale_x, tex_scale_y);
+	set_uniform_float2(deferred_omni, "fb_size", width, height);
+}
+
+void DeferredRenderer::render(const Level *level) const
+{
+	// render into the MRT buffers
+	glUseProgram(mrt_prog);
+	curr_prog = mrt_prog;
+
+	glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	level->draw();
+
+	glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+
+	// post-process lighting
+	glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_ONE, GL_ONE);
+
+	glDisable(GL_LIGHTING);
+	glDisable(GL_DEPTH_TEST);
+	glCullFace(GL_FRONT);
+
+	glUseProgram(deferred_omni);
+	curr_prog = deferred_omni;
+
+	for(int i=0; i<MRT_COUNT; i++) {
+		glActiveTexture(GL_TEXTURE0 + i);
+		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
+		glEnable(GL_TEXTURE_2D);
+	}
+
+	glDepthMask(0);
+	level->draw_lights();
+	glDepthMask(1);
+
+	for(int i=0; i<MRT_COUNT; i++) {
+		glActiveTexture(GL_TEXTURE0 + MRT_COUNT - i - 1);
+		glDisable(GL_TEXTURE_2D);
+	}
+
+	glUseProgram(0);
+	curr_prog = 0;
+	glPopAttrib();
+}
+
+static const char *fbstname[] = {
+	"GL_FRAMEBUFFER_COMPLETE",
+	"GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
+	"GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
+	"no such fbo error",
+	"GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
+	"GL_FRAMEBUFFER_INCOMPLETE_FORMATS",
+	"GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER",
+	"GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER",
+	"GL_FRAMEBUFFER_UNSUPPORTED"
+};
+
+bool DeferredRenderer::create_fbo()
+{
+	unsigned int clamp = GLEW_ARB_texture_border_clamp ? GL_CLAMP_TO_EDGE : GL_CLAMP;
+
+	// round the texture size up to the next power of 2
+	tex_xsz = round_pow2(width);
+	tex_ysz = round_pow2(height);
+
+	if(!glGenFramebuffersEXT) {
+		fprintf(stderr, "FBO support missing\n");
+		return false;
+	}
+	glGenFramebuffersEXT(1, &fbo);
+	glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
+
+	glGenTextures(MRT_COUNT, mrt_tex);
+	for(int i=0; i<MRT_COUNT; i++) {
+		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, tex_xsz, tex_ysz, 0, GL_RGBA, GL_FLOAT, 0);
+
+		// attach to fbo
+		glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+				GL_TEXTURE_2D, mrt_tex[i], 0);
+		CHECKGLERR;
+	}
+
+	static GLenum draw_bufs[] = {
+		GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT,
+		GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,
+		GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT,
+		GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT
+	};
+	glDrawBuffersARB(MRT_COUNT, draw_bufs);
+
+	glGenRenderbuffersEXT(1, &rbuf_depth);
+	glBindRenderbufferEXT(GL_RENDERBUFFER, rbuf_depth);
+	glRenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, tex_xsz, tex_ysz);
+	glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbuf_depth);
+
+	int fbst = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+	if(fbst != GL_FRAMEBUFFER_COMPLETE) {
+		fprintf(stderr, "incomplete fbo: %u (%s)\n", fbo, fbstname[fbst - GL_FRAMEBUFFER_COMPLETE]);
+		return false;
+	}
+	CHECKGLERR;
+
+	glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+	return true;
+}
+
+static unsigned int load_sdr(const char *vfname, const char *pfname)
+{
+	char vsfile[PATH_MAX], psfile[PATH_MAX];
+	const char *fname;
+	unsigned int prog;
+
+	if((fname = datafile_path(vfname))) {
+		strcpy(vsfile, fname);
+	} else {
+		vsfile[0] = 0;
+	}
+	if((fname = datafile_path(pfname))) {
+		strcpy(psfile, fname);
+	} else {
+		psfile[0] = 0;
+	}
+	if(!(prog = create_program_load(vsfile, psfile))) {
+		fprintf(stderr, "failed to load shader program (%s, %s)\n", vsfile, psfile);
+		return 0;
+	}
+	return prog;
+}
+
+static int round_pow2(int x)
+{
+	x--;
+	x = (x >> 1) | x;
+	x = (x >> 2) | x;
+	x = (x >> 4) | x;
+	x = (x >> 8) | x;
+	x = (x >> 16) | x;
+	return x + 1;
+}
+
+#ifdef DBG_VIS_MRT
+// visualize the MRT buffers
+static void draw_deferred_debug()
+{
+	glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT);
+	glUseProgram(deferred_debug);
+	glDisable(GL_DEPTH_TEST);
+
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+
+	for(int i=0; i<MRT_COUNT; i++) {
+		glActiveTexture(GL_TEXTURE0 + i);
+		glBindTexture(GL_TEXTURE_2D, mrt_tex[i]);
+		glEnable(GL_TEXTURE_2D);
+	}
+
+	glBegin(GL_QUADS);
+	glTexCoord2f(0, 0);
+	glVertex2f(-1, -1);
+	glTexCoord2f(1, 0);
+	glVertex2f(1, -1);
+	glTexCoord2f(1, 1);
+	glVertex2f(1, 1);
+	glTexCoord2f(0, 1);
+	glVertex2f(-1, 1);
+	glEnd();
+
+	for(int i=0; i<MRT_COUNT; i++) {
+		glActiveTexture(GL_TEXTURE0 + MRT_COUNT - i - 1);
+		glDisable(GL_TEXTURE_2D);
+	}
+
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+
+	glUseProgram(0);
+	glPopAttrib();
+}
+#endif
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/renderer_deferred.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/prototype/src/renderer_deferred.h	Thu Aug 30 05:35:00 2012 +0300
@@ -0,0 +1,35 @@
+#ifndef RENDERER_DEFERRED_H_
+#define RENDERER_DEFERRED_H_
+
+#include "renderer.h"
+
+#define MRT_COUNT	3
+
+class DeferredRenderer : public Renderer {
+private:
+	unsigned int fbo, rbuf_depth;
+	unsigned int mrt_tex[MRT_COUNT];
+	int tex_xsz, tex_ysz;
+
+	unsigned int mrt_prog;
+	unsigned int deferred_omni, deferred_debug;
+
+	mutable unsigned int curr_prog;
+
+	bool create_fbo();
+
+public:
+	DeferredRenderer();
+	~DeferredRenderer();
+
+	bool init(int xsz, int ysz);
+
+	int get_tangent_location() const;
+	unsigned int get_current_program() const;
+
+	void resize(int xsz, int ysz);
+
+	void render(const Level *level) const;
+};
+
+#endif	// RENDERER_DEFERRED_H_
diff -r 38e16366efc2 -r acfe0c0110fc prototype/src/tile.cc
--- a/prototype/src/tile.cc	Thu Aug 30 03:05:04 2012 +0300
+++ b/prototype/src/tile.cc	Thu Aug 30 05:35:00 2012 +0300
@@ -134,7 +134,7 @@
 {
 	int count = 0;
 
-	int attr_loc = get_tangent_location();
+	int attr_loc = rend->get_tangent_location();
 	if(attr_loc == -1) {
 		fprintf(stderr, "warning: failed to retrieve tangent attribute location while loading tile\n");
 	}