hdrHEADmaster

11 files changed, 463 insertions, 0 deletions

diff --git a/advanced_lighting/6.hdr/build.sh b/advanced_lighting/6.hdr/build.sh
new file mode 100755
index 0000000..3957e1d
--- /dev/null
+++ b/advanced_lighting/6.hdr/build.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+. ../../config
+TARGET='hdr'
+set -x
+gcc -o $TARGET $CFLAGS $INCLUDE $LFLAGS $TARGET.c $LIBS
diff --git a/advanced_lighting/6.hdr/hdr.c b/advanced_lighting/6.hdr/hdr.c
new file mode 100644
index 0000000..911f9da
--- /dev/null
+++ b/advanced_lighting/6.hdr/hdr.c
@@ -0,0 +1,254 @@
+#include "GL/glew.h"
+#include "GLFW/glfw3.h"
+
+#include "pwyazh.h"
+#include "pwyazh_GL.h"
+
+#include "common.h"
+
+#define LCOUNT	8
+
+int main(void)
+{
+	S32		width, height;
+
+	GLFWwindow	*window;
+	F64		time, last_time;
+
+	State		state = {0};
+
+	U32		wooodtex;
+
+	Mesh		*quad,
+			*cube,
+			*tubecube;
+
+	U32		blinn_shader,
+			hdr_shader,
+			light_shader,
+			normals_debug_shader;
+
+	U32		hdrfbo,
+			hdrcolorbuf,
+			hdrrbo;
+
+	S32		i;
+
+	F32		a, da, r;
+	V3F		lpos[LCOUNT];
+
+	F32		exposure;
+
+	S32		show_normals, show_lights;
+
+	width = 800;
+	height = 600;
+
+	/* NOTE(pryazha): GLFW init */
+	glfwSetErrorCallback(error_callback);
+
+	if (glfwInit() == GLFW_FALSE)
+		return 1;
+
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
+	window = glfwCreateWindow(width, height, "HDR", 0, 0);
+	if (!window)
+		goto error;
+
+	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+	glfwMakeContextCurrent(window);
+
+	if (glewInit() != GLEW_OK)
+		goto error;
+
+	glEnable(GL_DEPTH_TEST);
+
+	/* NOTE(pryazha): Program init */
+	state.arena = arena_alloc(Kilobytes(256));
+
+	state.input.first_mouse = 1;
+
+	state.camera = (Camera){ v3f(0.0f, 0.0f, 3.0f), 90.0f, 0.1f, 100.0f, 0.0f, 0.0f };
+	state.camera_dp = v3f_zero();
+
+	da = 2.0f*pi_F32/LCOUNT;
+	for (i = 0, a = 0.0f, r = 2.0f; i < LCOUNT; i++, a += da)
+		lpos[i] = v3f(f32_sin(a)*r, 0.0f, f32_cos(a)*r);
+
+	exposure = 1.0f;
+
+	show_normals = 0;
+	show_lights = 1;
+	
+	/* NOTE(pryazha): Textures */
+	wooodtex = load_texture_gamma("../../data/textures/wood.png", 1);
+
+	/* NOTE(pryazha): Meshes */
+	quad = mesh_gen_quad(state.arena);
+	cube = mesh_load_obj(state.arena, "../../data/models/cube.obj");
+	tubecube = mesh_load_obj(state.arena, "../../data/models/tube_with_cube.obj");
+
+	/* NOTE(pryazha): Shaders */
+	blinn_shader = create_shader_program("shaders/blinn.vert", "shaders/blinn.frag");
+	hdr_shader = create_shader_program("shaders/hdr.vert", "shaders/hdr.frag");
+	light_shader = create_shader_program("shaders/light.vert", "shaders/light.frag");
+	normals_debug_shader = create_shader_program_geom("shaders/normals_debug.vert",
+							  "shaders/normals_debug.frag",
+							  "shaders/normals_debug.geom");
+
+	/* NOTE(pryazha): Create HDR framebuffer, color buffer texture and
+	 * renderbuffer */
+	glGenFramebuffers(1, &hdrfbo);
+	glGenTextures(1, &hdrcolorbuf);
+	glBindTexture(GL_TEXTURE_2D, hdrcolorbuf);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, 0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glGenRenderbuffers(1, &hdrrbo);
+	glBindRenderbuffer(GL_RENDERBUFFER, hdrrbo);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, hdrfbo);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, hdrcolorbuf, 0);
+	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, hdrrbo);
+	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+		fprintf(stderr, "[ERROR] : GL : Failed to complete framebuffer\n");
+
+	glBindRenderbuffer(GL_RENDERBUFFER, 0);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+	last_time = glfwGetTime();
+
+	while (!glfwWindowShouldClose(window)) {
+		glfwPollEvents();
+		glfwGetFramebufferSize(window, &width, &height);
+		process_glfw_keyboard(window, &state.input);
+		process_glfw_mouse_pos(window, &state.input);
+
+		if (key_first_press(state.input.exit))
+			glfwSetWindowShouldClose(window, GLFW_TRUE);
+
+		/* NOTE(pryazha): Update */
+		F32	speed, sensitivity;
+		V3F	dv;
+
+		speed = 2.0f;
+		dv = get_dv_camera_first_person(&state.input, &state.camera, speed, state.dt);
+		state.camera_dp = v3f_add(state.camera_dp, dv);
+		state.camera_dp = v3f_scalef(state.camera_dp, 0.8f);
+		state.camera.pos = v3f_add(state.camera.pos, state.camera_dp);
+
+		sensitivity = 0.1f;
+		state.input.mouse_offset = v2f_scalef(state.input.mouse_offset, sensitivity);
+		state.camera.yaw += state.input.mouse_offset.x;
+		state.camera.pitch += state.input.mouse_offset.y;
+		if (state.camera.pitch > 89.0f)
+			state.camera.pitch = 89.0f;
+		if (state.camera.pitch < -89.0f)
+			state.camera.pitch = -89.0f;
+
+		if (key_first_press(state.input.jump)) {
+			show_normals = !show_normals;
+			show_lights = !show_lights;
+		}
+
+		if (key_is_pressed(state.input.action_down))
+			exposure -= 0.01f;
+		if (key_is_pressed(state.input.action_up))
+			exposure += 0.01f;
+
+		for (i = 0; i < LCOUNT; i++)
+			lpos[i].y = f32_sin(glfwGetTime()+i);
+
+		/* NOTE(pryazha): Render */
+		F32	ar;
+		MAT4	proj, view, model;
+		char	lstr[1024];
+
+		ar = (F32)width/(F32)height;
+		proj = camera_persp(state.camera, ar);
+		view = get_view_matrix(&state.camera);
+
+		glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
+
+		glBindFramebuffer(GL_FRAMEBUFFER, hdrfbo);
+
+		glViewport(0, 0, width, height);
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		model = mat4_identity();
+
+		glUseProgram(blinn_shader);
+		shader_set_mat4fv(blinn_shader, "proj", proj); 
+		shader_set_mat4fv(blinn_shader, "view", view);
+		shader_set_mat4fv(blinn_shader, "model", model);
+		shader_set_1i(blinn_shader, "lcount", LCOUNT);
+		for (i = 0; i < LCOUNT; i++) {
+			snprintf(lstr, 1024, "lpos[%d]", i);
+			shader_set_3fv(blinn_shader, lstr, lpos[i]);
+		}
+		glBindTexture(GL_TEXTURE_2D, wooodtex);
+		shader_set_1i(blinn_shader, "invert_normals", 0);
+		mesh_draw(cube);
+		shader_set_1i(blinn_shader, "invert_normals", 1);
+		mesh_draw(tubecube);
+		glBindTexture(GL_TEXTURE_2D, 0);
+		glUseProgram(0);
+
+		if (show_lights) {
+			glUseProgram(light_shader);
+			shader_set_mat4fv(light_shader, "proj", proj); 
+			shader_set_mat4fv(light_shader, "view", view);
+			for (i = 0; i < LCOUNT; i++) {
+				model = mat4_make_scale(v3f(0.2f, 0.2f, 0.2f));
+				model = mat4_translate(model, lpos[i]);
+				shader_set_mat4fv(light_shader, "model", model);
+				mesh_draw(cube);
+			}
+			glUseProgram(0);
+		}
+
+		if (show_normals) {
+			model = mat4_identity();
+
+			glUseProgram(normals_debug_shader);
+			shader_set_mat4fv(normals_debug_shader, "proj", proj); 
+			shader_set_mat4fv(normals_debug_shader, "view", view);
+			shader_set_mat4fv(normals_debug_shader, "model", model);
+			mesh_draw(cube);
+			glUseProgram(0);
+		}
+
+		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glUseProgram(hdr_shader);
+		shader_set_1f(hdr_shader, "exposure", exposure);
+		glBindTexture(GL_TEXTURE_2D, hdrcolorbuf);
+		mesh_draw(quad);
+		glUseProgram(0);
+
+		glfwSwapBuffers(window);
+
+		time = glfwGetTime();
+		state.dt = time-last_time;
+		last_time = time;
+
+		input_update_last_state(&state.input);
+	}
+
+	arena_release(state.arena);
+	glfwTerminate();
+	return 0;
+
+error:
+	arena_release(state.arena);
+	glfwTerminate();
+	return 1;
+}
diff --git a/advanced_lighting/6.hdr/shaders/blinn.frag b/advanced_lighting/6.hdr/shaders/blinn.frag
new file mode 100644
index 0000000..5dca1f7
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/blinn.frag
@@ -0,0 +1,54 @@
+#version 330 core
+
+in VS_OUT {
+	vec3		fpos;
+	vec3		fn;
+	vec2		texc;
+} fsin;
+
+out vec4		fcolor;
+
+uniform sampler2D	diftex;
+
+const int		lmax = 30;
+
+uniform int		lcount;
+uniform	vec3		lpos[lmax];
+uniform vec3		vpos;
+
+void main(void)
+{
+	vec3	l, v, n, difcolor, lcolor, ambient, halfdir, result;
+	float	diff, spec, specf, dist, attenuation;
+	int	i;
+
+	n = normalize(fsin.fn);
+	v = normalize(vpos-fsin.fpos);
+
+	ambient = vec3(0.001);
+
+	difcolor = vec3(texture(diftex, fsin.texc));
+
+	/* lcolor = vec3(0.3, 0.0, 0.1); */
+	lcolor = vec3(1.0);
+
+	specf = 0.2;
+
+	result = vec3(0.0);
+
+	for (i = 0; i < lcount; i++) {
+		l = normalize(lpos[i]-fsin.fpos);
+		halfdir = normalize(l+v);
+
+		diff = max(dot(n, l), 0.0);
+
+		spec = pow(max(dot(n, halfdir), 0.0), 16.0)*specf;
+
+		dist = length(lpos[i]-fsin.fpos);
+		attenuation = 1.0/dist;
+
+		result += (diff+spec)*difcolor*lcolor*attenuation;
+	}
+
+	fcolor = vec4(ambient+result, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/blinn.vert b/advanced_lighting/6.hdr/shaders/blinn.vert
new file mode 100644
index 0000000..f08f38e
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/blinn.vert
@@ -0,0 +1,34 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec3 anormal;
+layout(location = 2) in vec2 atexc;
+
+out VS_OUT {
+	vec3	fpos;
+	vec3	fn;
+	vec2	texc;
+} vsout;
+
+uniform mat4	proj;
+uniform mat4	view;
+uniform mat4	model;
+
+uniform bool	invert_normals;
+
+void main(void)
+{
+	mat3	normtransf;
+
+	vsout.fpos = vec3(model*vec4(apos, 1.0));
+
+	normtransf = mat3(transpose(inverse(model)));
+
+	if (invert_normals)
+		vsout.fn = normtransf*(-anormal);
+	else
+		vsout.fn = normtransf*anormal;
+
+	vsout.texc = atexc;
+
+	gl_Position = proj*view*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/hdr.frag b/advanced_lighting/6.hdr/shaders/hdr.frag
new file mode 100644
index 0000000..f12c6a8
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/hdr.frag
@@ -0,0 +1,29 @@
+#version 330 core
+
+in VSOUT {
+	vec2		texc;
+} vsout;
+
+out vec4		fcolor;
+
+uniform sampler2D	hdrbuf;
+uniform float		exposure;
+
+void main(void)
+{
+	const float	gamma = 2.2;
+
+	vec3		hdrcolor, mapped;
+
+	hdrcolor = vec3(texture(hdrbuf, vsout.texc));
+
+	/* NOTE(pryazha): Reinhard tone mapping */
+	/* mapped = hdrcolor/(hdrcolor+vec3(1.0)); */
+
+	/* NOTE(pryazha): Tone mapping with exposure (i guess) */
+	mapped = vec3(1.0)-exp(-hdrcolor*exposure);
+
+	mapped = pow(mapped, vec3(1.0/gamma));
+
+	fcolor = vec4(mapped, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/hdr.vert b/advanced_lighting/6.hdr/shaders/hdr.vert
new file mode 100644
index 0000000..4f15c72
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/hdr.vert
@@ -0,0 +1,14 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 2) in vec2 atexc;
+
+out VSOUT {
+	vec2	texc;
+} vsout;
+
+void main(void)
+{
+	vsout.texc = atexc;
+
+	gl_Position = vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/light.frag b/advanced_lighting/6.hdr/shaders/light.frag
new file mode 100644
index 0000000..3829c91
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/light.frag
@@ -0,0 +1,8 @@
+#version 330 core
+
+out vec4 fcolor;
+
+void main(void)
+{
+	fcolor = vec4(1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/light.vert b/advanced_lighting/6.hdr/shaders/light.vert
new file mode 100644
index 0000000..a24ade5
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/light.vert
@@ -0,0 +1,11 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+
+uniform mat4 proj;
+uniform mat4 view;
+uniform mat4 model;
+
+void main(void)
+{
+	gl_Position = proj*view*model*vec4(apos, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/normals_debug.frag b/advanced_lighting/6.hdr/shaders/normals_debug.frag
new file mode 100644
index 0000000..32e36a7
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/normals_debug.frag
@@ -0,0 +1,10 @@
+#version 330 core
+
+in vec3 vcolor;
+
+out vec4 frag_color;
+
+void main(void)
+{
+	frag_color = vec4(vcolor, 1.0);
+}
diff --git a/advanced_lighting/6.hdr/shaders/normals_debug.geom b/advanced_lighting/6.hdr/shaders/normals_debug.geom
new file mode 100644
index 0000000..bdbc1b3
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/normals_debug.geom
@@ -0,0 +1,28 @@
+#version 330 core
+layout(triangles) in;
+layout(line_strip, max_vertices=6) out;
+
+in VS_OUT {
+	vec4 normal;
+} gs_in[];
+
+out vec3 vcolor;
+
+uniform mat4 proj;
+
+void gen_normals(int index)
+{
+	vcolor = vec3(0.0, 1.0, 0.0);
+	gl_Position = proj*(gl_in[index].gl_Position);
+	EmitVertex();
+	gl_Position = proj*(gl_in[index].gl_Position+0.5*gs_in[index].normal);
+	EmitVertex();
+	EndPrimitive();
+}
+
+void main(void)
+{
+	gen_normals(0);
+	gen_normals(1);
+	gen_normals(2);
+}
diff --git a/advanced_lighting/6.hdr/shaders/normals_debug.vert b/advanced_lighting/6.hdr/shaders/normals_debug.vert
new file mode 100644
index 0000000..2d3a4b5
--- /dev/null
+++ b/advanced_lighting/6.hdr/shaders/normals_debug.vert
@@ -0,0 +1,16 @@
+#version 330 core
+layout(location = 0) in vec3 apos;
+layout(location = 1) in vec3 anormal;
+
+out VS_OUT {
+	vec4 normal;
+} vs_out;
+
+uniform mat4 view;
+uniform mat4 model;
+
+void main(void)
+{
+	vs_out.normal = view*model*vec4(normalize(anormal), 0.0);
+	gl_Position = view*model*vec4(apos, 1.0);
+}