asset_render.c

/* This file is part of punani-strike
 * Copyright (c) 2012 Gianni Tedesco
 * Released under the terms of GPLv3
*/
#include <punani/punani.h>
#include <punani/vec.h>
#include <punani/renderer.h>
#include <punani/light.h>
#include <punani/asset.h>
#include <punani/blob.h>
#include <math.h>

#include "list.h"
#include "assetfile.h"

#include <punani/punani_gl.h>
#include <math.h>

#define M_INFINITY 400.0f

static void translate_light_pos(renderer_t r, vec3_t light_pos)
{
	vec3_t res;
	renderer_xlat_world_to_obj(r, res, light_pos);
	v_normalize(res);
	light_pos[0] = -res[0];
	light_pos[1] = -res[1];
	light_pos[2] = -res[2];
}

static void extrude_vert(struct _asset_file *f, unsigned int i)
{
	float *e = f->f_verts_ex + 3 * f->f_hdr->h_verts;
	const struct asset_vbo *v = f->f_verts;

	e[i * 3 + 0] = v[i].v_vert[0] + f->f_lightpos[0] * M_INFINITY;
	e[i * 3 + 1] = v[i].v_vert[1] + f->f_lightpos[1] * M_INFINITY;
	e[i * 3 + 2] = v[i].v_vert[2] + f->f_lightpos[2] * M_INFINITY;
}

static void copy_vert(struct _asset_file *f, unsigned int i)
{
	float *e = f->f_verts_ex;
	const struct asset_vbo *v = f->f_verts;

	e[i * 3 + 0] = v[i].v_vert[0];
	e[i * 3 + 1] = v[i].v_vert[1];
	e[i * 3 + 2] = v[i].v_vert[2];
}

static void extrude_verts(struct _asset_file *f)
{
	unsigned int i;

	for(i = 0; i < f->f_hdr->h_verts; i++) {
		copy_vert(f, i);
		extrude_vert(f, i);
	}
}

static void emit_vert(idx_t **out, idx_t a)
{
	**out = a;
	(*out)++;
}

static void emit_tri(idx_t **out, idx_t a, idx_t b, idx_t c)
{
	emit_vert(out, a);
	emit_vert(out, b);
	emit_vert(out, c);
}

static unsigned int calc_vol(struct _asset_file *f, uint16_t tri[3], idx_t *out)
{
	unsigned int i;
	vec3_t s[3];
	idx_t surf[3];
	idx_t esurf[3];
	vec3_t a, b, c, d;

	for(i = 0; i < 3; i++) {
		surf[i] = tri[i];
	}

	for(i = 0; i < 3; i++) {
		s[i][0] = f->f_verts[tri[i]].v_vert[0];
		s[i][1] = f->f_verts[tri[i]].v_vert[1];
		s[i][2] = f->f_verts[tri[i]].v_vert[2];
	}

	for(i = 0; i < 3; i++) {
		esurf[i] = tri[i] + f->f_hdr->h_verts;
	}

	/* don't cast shadows for triangles not facing light */
	v_sub(a, s[1], s[0]);
	v_sub(b, s[2], s[0]);
	v_cross_product(c, a, b);
	v_normalize(c);
	for(i = 0; i < 3; i++)
		d[i] = f->f_lightpos[i];
	v_normalize(d);
	if ( v_dot_product(c, d) < 0 )
		return 0;

#if SHADOW_CAPS
	emit_tri(&out, esurf[2], esurf[1], esurf[0]);
	emit_tri(&out, surf[0], surf[1], surf[2]);
#endif

	for(i = 0; i < 3; i++) {
		unsigned int a, b;

		a = (i % 3);
		b = ((i + 1) % 3);

		emit_tri(&out, surf[a], esurf[a], surf[b]);
		emit_tri(&out, surf[b], esurf[a], esurf[b]);
	}

#if SHADOW_CAPS
	return 8;
#else
	return 6;
#endif
}

static unsigned int calc_asset_vol(struct _asset *a)
{
	struct _asset_file *f = a->a_owner;
	const struct asset_desc *d = f->f_desc + a->a_idx;
	unsigned int i, num_tris, ret = 0;
	idx_t tri[3];
	idx_t *out = a->a_shadow_idx;

	for(i = 0; i < d->a_num_idx; i += 3) {
		tri[0] = a->a_indices[i + 0];
		tri[1] = a->a_indices[i + 1];
		tri[2] = a->a_indices[i + 2];
		num_tris = calc_vol(f, tri, out);
		out += num_tris * 3;
		ret += num_tris * 3;
	}

	return ret;
}

static void update_shadow_buffers(struct _asset_file *f)
{
	if ( !f->f_vbo_shadow ) {
		glGenBuffers(1, &f->f_vbo_shadow);
	}

	if ( !f->f_ibo_shadow ) {
		glGenBuffers(1, &f->f_ibo_shadow);
	}

	glBindBuffer(GL_ARRAY_BUFFER, f->f_vbo_shadow);
	glBufferData(GL_ARRAY_BUFFER,
			sizeof(*f->f_verts_ex) * f->f_hdr->h_verts * 6,
			NULL, GL_STATIC_DRAW);
	glBufferData(GL_ARRAY_BUFFER,
			sizeof(*f->f_verts_ex) * f->f_hdr->h_verts * 6,
			f->f_verts_ex, GL_STATIC_DRAW);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_shadow);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
			sizeof(*f->f_idx_shadow) * f->f_shadow_indices,
			NULL, GL_STATIC_DRAW);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
			sizeof(*f->f_idx_shadow) * f->f_shadow_indices,
			f->f_idx_shadow, GL_STATIC_DRAW);
}

static void recalc_shadows(struct _asset_file *f, renderer_t r, light_t l)
{
	unsigned int i, shadow_off = 0;

	/* get light position */
	light_get_pos(l, f->f_lightpos);
	translate_light_pos(r, f->f_lightpos);

	/* extrude all vertices */
	extrude_verts(f);

	/* construct shadow geometry for all loaded assets */
	for(i = 0; i < f->f_hdr->h_num_assets; i++) {
		struct _asset *a;

		a = f->f_db[i];
		if ( NULL == a )
			continue;

		a->a_shadow_idx = f->f_idx_shadow + shadow_off;
		a->a_num_shadow_idx = calc_asset_vol(a);
		shadow_off += a->a_num_shadow_idx;
	}

	update_shadow_buffers(f);
}

void asset_file_render_begin(asset_file_t f, renderer_t r, light_t l)
{
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_NORMAL_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);

	if ( l && f->f_shadows_dirty ) {
		recalc_shadows(f, r, l);
		f->f_shadows_dirty = 0;
	}

	if ( !f->f_vbo_geom ) {
		if ( glGenBuffers ) {
			glGenBuffers(1, &f->f_vbo_geom);
			glBindBuffer(GL_ARRAY_BUFFER, f->f_vbo_geom);
			glBufferData(GL_ARRAY_BUFFER,
					sizeof(*f->f_verts) * f->f_hdr->h_verts,
					NULL, GL_STATIC_DRAW);
			glBufferData(GL_ARRAY_BUFFER,
					sizeof(*f->f_verts) * f->f_hdr->h_verts,
					f->f_verts, GL_STATIC_DRAW);
		}else{
			glGenBuffersARB(1, &f->f_vbo_geom);
			glBindBufferARB(GL_ARRAY_BUFFER, f->f_vbo_geom);
			glBufferDataARB(GL_ARRAY_BUFFER,
					sizeof(*f->f_verts) * f->f_hdr->h_verts,
					NULL, GL_STATIC_DRAW);
			glBufferDataARB(GL_ARRAY_BUFFER,
					sizeof(*f->f_verts) * f->f_hdr->h_verts,
					f->f_verts, GL_STATIC_DRAW);
		}
	}

	if ( !f->f_ibo_geom ) {
		if ( glGenBuffers ) {
			glGenBuffers(1, &f->f_ibo_geom);
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_geom);
			glBufferData(GL_ELEMENT_ARRAY_BUFFER,
					sizeof(*f->f_idx_begin) * f->f_num_indices,
					NULL, GL_STATIC_DRAW);
			glBufferData(GL_ELEMENT_ARRAY_BUFFER,
					sizeof(*f->f_idx_begin) * f->f_num_indices,
					f->f_idx_begin, GL_STATIC_DRAW);
		}else{
			glGenBuffersARB(1, &f->f_ibo_geom);
			glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_geom);
			glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER,
					sizeof(*f->f_idx_begin) * f->f_num_indices,
					NULL, GL_STATIC_DRAW);
			glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER,
					sizeof(*f->f_idx_begin) * f->f_num_indices,
					f->f_idx_begin, GL_STATIC_DRAW);
		}
	}
}

void asset_file_render_end(asset_file_t f)
{
	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);
	glDisableClientState(GL_COLOR_ARRAY);
}

static void render_vol(struct _asset *a)
{
	struct _asset_file *f = a->a_owner;

	glDisableClientState(GL_NORMAL_ARRAY);
	glDisableClientState(GL_COLOR_ARRAY);
	if ( f->f_vbo_shadow && f->f_ibo_shadow ) {
		glBindBuffer(GL_ARRAY_BUFFER, f->f_vbo_shadow);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_shadow);

		glVertexPointer(3, GL_FLOAT, 0, 0);

		glDrawElements(GL_TRIANGLES, a->a_num_shadow_idx,
				GL_UNSIGNED_SHORT,
				(void *)((a->a_shadow_idx -
					f->f_idx_shadow) * sizeof(idx_t)));
	}else{
		glVertexPointer(3, GL_FLOAT, 0, f->f_verts_ex);
		glDrawElements(GL_TRIANGLES,
				a->a_num_shadow_idx,
				GL_UNSIGNED_SHORT,
				a->a_shadow_idx);
	}
	glEnableClientState(GL_NORMAL_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
}

static void render_shadow(asset_t a, renderer_t r, light_t l)
{
#if 1
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDepthMask(GL_FALSE);
	if ( GLEW_EXT_stencil_two_side ) {
		glDisable(GL_CULL_FACE);
		glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
	}else{
		glEnable(GL_CULL_FACE);
	}
	glEnable(GL_STENCIL_TEST);
	glEnable(GL_POLYGON_OFFSET_FILL);
	glPolygonOffset(0.0f, 100.0f);

	if ( GLEW_EXT_stencil_two_side ) {
		glActiveStencilFaceEXT(GL_BACK);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
	}else{
		glCullFace(GL_BACK);
		glStencilFunc(GL_ALWAYS, 0x0, ~0);
		glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
		render_vol(a);
	}

	if ( GLEW_EXT_stencil_two_side ) {
		glActiveStencilFaceEXT(GL_FRONT);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glStencilOp(GL_KEEP, GL_KEEP, GL_DECR_WRAP_EXT);
	}else{
		glCullFace(GL_FRONT);
		glStencilFunc(GL_ALWAYS, 0x0, ~0);
		glStencilOp(GL_KEEP, GL_KEEP, GL_INCR_WRAP_EXT);
	}
#endif

	render_vol(a);

	glDisable(GL_POLYGON_OFFSET_FILL);
	glDisable(GL_CULL_FACE);
	glDisable(GL_STENCIL_TEST);
	glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}

static void render_asset(asset_t a, renderer_t r)
{
	struct _asset_file *f = a->a_owner;
	const struct asset_desc *d = f->f_desc + a->a_idx;

	if ( f->f_vbo_geom && f->f_ibo_geom ) {
		if ( glBindBuffer ) {
			glBindBuffer(GL_ARRAY_BUFFER, f->f_vbo_geom);
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_geom);
		}else{
			glBindBufferARB(GL_ARRAY_BUFFER, f->f_vbo_geom);
			glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, f->f_ibo_geom);
		}

		glVertexPointer(3, GL_FLOAT, sizeof(*f->f_verts), 0);
		glNormalPointer(GL_FLOAT, sizeof(*f->f_verts), (void *)12);
		glColorPointer(3, GL_UNSIGNED_BYTE, sizeof(*f->f_verts), (void *)24);

		glDrawElements(GL_TRIANGLES, d->a_num_idx,
				GL_UNSIGNED_SHORT,
				(void *)((a->a_indices -
					f->f_idx_begin) * sizeof(idx_t)));
	}else{
		glVertexPointer(3, GL_FLOAT, sizeof(*f->f_verts), f->f_verts);
		glNormalPointer(GL_FLOAT, sizeof(*f->f_verts), (void *)&f->f_verts[0].v_norm);
		glColorPointer(4, GL_BYTE, sizeof(*f->f_verts), (void *)&f->f_verts[0].v_rgba);
		glDrawElements(GL_TRIANGLES, d->a_num_idx,
				GL_UNSIGNED_SHORT,
				a->a_indices);
	}
}

void asset_render(asset_t a, renderer_t r, light_t l)
{
	if ( l ) {
		render_shadow(a, r, l);
	}else{
		render_asset(a, r);
	}
}