cinnaboot
/
hexgame
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

clean up renderer to render_group implementation

master
cinnaboot 8 years ago
parent
6cc979d44c
commit
0aed6588f5
5 changed files with 124 additions and 178 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 170
      src/render_group.cpp
  2. 13
      src/render_group.h
  3. 101
      src/renderer.cpp
  4. 2
      src/util.cpp
  5. 10
      src/util.h

170
src/render_group.cpp
Unescape View File

@ -42,19 +42,14 @@ rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char *
glDeleteShader(vertex_shader_id); glDeleteShader(vertex_shader_id);
glDeleteShader(fragment_shader_id); glDeleteShader(fragment_shader_id);
// check for errors
GLint isLinked = 0; GLint isLinked = 0;
glGetProgramiv(rg->program_id, GL_LINK_STATUS, &isLinked); glGetProgramiv(rg->program_id, GL_LINK_STATUS, &isLinked);
if (isLinked == GL_FALSE) { if (isLinked == GL_FALSE) {
GLint maxLength = 0; GLint maxLength = 0;
glGetProgramiv(rg->program_id, GL_INFO_LOG_LENGTH, &maxLength); glGetProgramiv(rg->program_id, GL_INFO_LOG_LENGTH, &maxLength);
// The maxLength includes the NULL character
GLchar infoLog[maxLength]; GLchar infoLog[maxLength];
glGetProgramInfoLog(rg->program_id, maxLength, &maxLength, &infoLog[0]); glGetProgramInfoLog(rg->program_id, maxLength, &maxLength, &infoLog[0]);
LOG(ERROR) << infoLog << "\n"; LOG(ERROR) << infoLog << "\n";
// The program is useless now. So delete it.
glDeleteProgram(rg->program_id); glDeleteProgram(rg->program_id);
return false; return false;
@ -63,32 +58,44 @@ rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char *
return true; return true;
} }
void gl_buffer *
rgInitGLBufferObject(gl_buffer* buf_obj, uint len, GLenum usage, GLenum target, GLfloat data[]) rgInitGLBuffer(gl_buffer* buffer, uint buffer_len)
{ {
// TODO: why not just assing the pointer to the render group instead of copying here? buffer->buffer_len = buffer_len;
buf_obj->buffer_len = len; buffer->buffer = (GLfloat*) std::calloc(buffer_len, sizeof(GLfloat));
buf_obj->buffer = (GLfloat*) std::calloc(len, sizeof(GLfloat));
if (data) if (!buffer->buffer)
LOG(ERROR) << "Error allocating memory\n";
return buffer;
}
gl_index_buffer *
initGLIndexBuffer(gl_index_buffer* index_buffer, uint buffer_len)
{ {
for (uint i = 0; i < len; i++) index_buffer->buffer_len = buffer_len;
buf_obj->buffer[i] = data[i]; index_buffer->buffer = (uint*) std::calloc(buffer_len, sizeof(uint));
if (!index_buffer->buffer)
LOG(ERROR) << "Error allocating memory\n";
return index_buffer;
} }
glGenBuffers(1, &buf_obj->buffer_id); void
glBindBuffer(target, buf_obj->buffer_id); rgSendBufferToGL(gl_buffer* buffer, GLenum usage, GLenum target)
glBufferData(target, len * sizeof(GLfloat), buf_obj->buffer, usage); {
glGenBuffers(1, &buffer->buffer_id);
glBindBuffer(target, buffer->buffer_id);
glBufferData(target, buffer->buffer_len * sizeof(GLfloat), buffer->buffer, usage);
} }
// NOTE: helper for fillColorBuffer() to convert uint32 color to GLfloat triplet
void void
convertColor(GLfloat buf[3], uint32 color) sendIndexBufferToGL(gl_index_buffer* index_buffer, GLenum usage, GLenum target)
{ {
// NOTE: not using the alpha values for now glGenBuffers(1, &index_buffer->buffer_id);
buf[0] = (GLfloat) ((color >> 24) & 0xFF) / (GLfloat) 255; glBindBuffer(target, index_buffer->buffer_id);
buf[1] = (GLfloat) ((color >> 16) & 0xFF) / (GLfloat) 255; glBufferData(target, index_buffer->buffer_len * sizeof(uint), index_buffer->buffer, usage);
buf[2] = (GLfloat) ((color >> 8) & 0xFF) / (GLfloat) 255;
} }
void void
@ -101,7 +108,7 @@ rgFillColorBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes)
{ {
buf_idx = i * buf_len_per_hex; buf_idx = i * buf_len_per_hex;
hex_info hxi = (*hexes)[i]; hex_info hxi = (*hexes)[i];
convertColor(color_buf, hxi.current_color); utilConvertColor(color_buf, hxi.current_color);
for (int j = 0; j < buf_len_per_hex; j+=3) for (int j = 0; j < buf_len_per_hex; j+=3)
{ {
@ -112,20 +119,23 @@ rgFillColorBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes)
} }
} }
// Copy assimp data to our structures for openGL
bool bool
rgInitEntity(gl_render_group* rg, Entity* e) rgInitEntity(gl_render_group* rg, Entity* e)
{ {
bool retVal = true; rg->draw_indexed = true;
bool useNormals = rg->use_normals = (e->mesh->normals != nullptr); rg->use_normals = (e->mesh->normals != nullptr);
uint vertex_buf_len = e->mesh->num_vertices * 3; uint vertex_buf_len = e->mesh->num_vertices * 3;
GLfloat* vertex_buf = (GLfloat*) std::calloc(vertex_buf_len, sizeof(GLfloat));
GLfloat* color_buf = (GLfloat*) std::calloc(vertex_buf_len, sizeof(GLfloat));
GLfloat* normal_buf;
if (useNormals)
normal_buf = (GLfloat*) std::calloc(vertex_buf_len, sizeof(GLfloat));
// dump vertices, colors, and normals into temporary buffers GLfloat* vertex_buf = rgInitGLBuffer(&rg->vertex_buffer, vertex_buf_len)->buffer;
GLfloat* color_buf = rgInitGLBuffer(&rg->color_buffer, vertex_buf_len)->buffer;
GLfloat* normal_buf = rgInitGLBuffer(&rg->normal_buffer, vertex_buf_len)->buffer;
uint* index_buf = initGLIndexBuffer(&rg->index_buffer, e->mesh->num_indices)->buffer;
if (!vertex_buf || !color_buf || !normal_buf || !index_buf)
return false;
// dump vertices, colors, and normals into render_group buffers
uint vertex_index = 0; uint vertex_index = 0;
uint vertex_prop_index = 0; uint vertex_prop_index = 0;
@ -139,7 +149,7 @@ rgInitEntity(gl_render_group* rg, Entity* e)
case 2: vertex_buf[i] = vertex.z; break; case 2: vertex_buf[i] = vertex.z; break;
} }
if (useNormals) { if (rg->use_normals) {
switch (vertex_prop_index) { switch (vertex_prop_index) {
case 0: normal_buf[i] = normal.x; break; case 0: normal_buf[i] = normal.x; break;
case 1: normal_buf[i] = normal.y; break; case 1: normal_buf[i] = normal.y; break;
@ -156,41 +166,17 @@ rgInitEntity(gl_render_group* rg, Entity* e)
} }
} }
// send vertex and color data to OpenGL // dump indices
rgInitGLBufferObject(&rg->vertex_buffer, vertex_buf_len,
GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, vertex_buf);
rgInitGLBufferObject(&rg->color_buffer, vertex_buf_len,
GL_STATIC_DRAW, GL_ARRAY_BUFFER, color_buf);
if (useNormals) {
rgInitGLBufferObject(&rg->vertex_normals, vertex_buf_len,
GL_STATIC_DRAW, GL_ARRAY_BUFFER, normal_buf);
}
// TODO: combine this somehow with rgInitGLBufferObject()
// dump indices into temp buffer
gl_index_buffer index_buffer;
index_buffer.buffer_len = e->mesh->num_indices;
index_buffer.indices = (uint *) std::calloc(e->mesh->num_indices, sizeof(uint));
for (uint i = 0; i < e->mesh->num_indices; i++) for (uint i = 0; i < e->mesh->num_indices; i++)
index_buffer.indices[i] = e->mesh->indices[i]; index_buf[i] = e->mesh->indices[i];
rg->index_buffer = index_buffer; rgSendBufferToGL(&rg->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
rgSendBufferToGL(&rg->color_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
glGenBuffers(1, &rg->index_buffer.buffer_id); if (rg->use_normals)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.buffer_id); rgSendBufferToGL(&rg->normal_buffer, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, e->mesh->num_indices * sizeof(uint), sendIndexBufferToGL(&rg->index_buffer, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER);
rg->index_buffer.indices, GL_STATIC_DRAW);
// free temp buffers
std::free(vertex_buf);
if (useNormals) std::free(normal_buf);
std::free(color_buf);
vertex_buf = normal_buf = color_buf = nullptr;
return retVal; return true;
} }
void void
@ -229,7 +215,7 @@ rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
// 3rd attribute buffer: normals // 3rd attribute buffer: normals
if (rg->use_normals) { if (rg->use_normals) {
glEnableVertexAttribArray(2); glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, rg->vertex_normals.buffer_id); glBindBuffer(GL_ARRAY_BUFFER, rg->normal_buffer.buffer_id);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
// TODO: testing lighting // TODO: testing lighting
@ -239,52 +225,12 @@ rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
} }
// draw // draw
glDrawArrays(draw_mode, 0, rg->vertex_buffer.buffer_len / 3); if (rg->draw_indexed) {
// cleanup
glDisableVertexAttribArray(0);
if (rg->color_buffer.buffer)
glDisableVertexAttribArray(1);
}
void
rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
glm::mat4 view_matrix, glm::mat4 projection_matrix,
glm::vec3 light_position, GLuint light_id)
{
glUseProgram(rg->program_id);
glUniformMatrix4fv(rg->model_matrix_id, 1, GL_FALSE, &model_matrix[0][0]);
glUniformMatrix4fv(rg->view_matrix_id, 1, GL_FALSE, &view_matrix[0][0]);
glUniformMatrix4fv(rg->projection_matrix_id, 1, GL_FALSE, &projection_matrix[0][0]);
// TODO: testing lighting
glUniform3f(light_id, light_position.x, light_position.y, light_position.z);
glm::mat3 normal_matrix = glm::transpose(glm::inverse(glm::mat3(model_matrix)));
glUniformMatrix3fv(rg->normal_matrix_id, 1, GL_FALSE, &normal_matrix[0][0]);
// 1st attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, rg->vertex_buffer.buffer_id);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
// 2nd attribute buffer : colors
if (rg->color_buffer.buffer)
{
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, rg->color_buffer.buffer_id);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
}
// 3rd attribe buffer : normals
if (rg->use_normals) {
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, rg->vertex_normals.buffer_id);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*) 0);
}
// draw
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.buffer_id); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rg->index_buffer.buffer_id);
glDrawElements(draw_mode, rg->index_buffer.buffer_len, GL_UNSIGNED_INT, 0); glDrawElements(draw_mode, rg->index_buffer.buffer_len, GL_UNSIGNED_INT, 0);
} else {
glDrawArrays(draw_mode, 0, rg->vertex_buffer.buffer_len / 3);
}
// cleanup // cleanup
glDisableVertexAttribArray(0); glDisableVertexAttribArray(0);
@ -301,8 +247,8 @@ rgFree(gl_render_group* rg)
return; return;
utilSafeFree(rg->vertex_buffer.buffer); utilSafeFree(rg->vertex_buffer.buffer);
utilSafeFree(rg->vertex_normals.buffer); utilSafeFree(rg->normal_buffer.buffer);
utilSafeFree(rg->index_buffer.indices); utilSafeFree(rg->index_buffer.buffer);
utilSafeFree(rg->color_buffer.buffer); utilSafeFree(rg->color_buffer.buffer);
utilSafeFree(rg); utilSafeFree(rg);
} }

13
src/render_group.h
Unescape View File

@ -15,13 +15,13 @@ struct gl_index_buffer
{ {
GLuint buffer_id = 0; GLuint buffer_id = 0;
size_t buffer_len = 0; size_t buffer_len = 0;
uint* indices = nullptr; uint* buffer = nullptr;
}; };
struct gl_render_group struct gl_render_group
{ {
gl_buffer vertex_buffer; gl_buffer vertex_buffer;
gl_buffer vertex_normals; gl_buffer normal_buffer;
gl_buffer color_buffer; gl_buffer color_buffer;
gl_index_buffer index_buffer; gl_index_buffer index_buffer;
GLuint program_id = 0; GLuint program_id = 0;
@ -31,6 +31,7 @@ struct gl_render_group
GLuint normal_matrix_id = 0; GLuint normal_matrix_id = 0;
GLuint vertex_array_id = 0; GLuint vertex_array_id = 0;
bool use_normals = false; bool use_normals = false;
bool draw_indexed = false;
}; };
typedef struct gl_buffer gl_buffer; typedef struct gl_buffer gl_buffer;
@ -39,7 +40,9 @@ typedef struct gl_render_group gl_render_group;
bool rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char * frag_code); bool rgInitShaderProgram(gl_render_group* rg, const char * vertex_code, const char * frag_code);
void rgInitGLBufferObject(gl_buffer* buf_obj, uint len, GLenum usage, GLenum target, GLfloat data[]); gl_buffer * rgInitGLBuffer(gl_buffer* buffer, uint buffer_len);
void rgSendBufferToGL(gl_buffer* buffer, GLenum usage, GLenum target);
bool rgInitEntity(gl_render_group* rg, Entity* e); bool rgInitEntity(gl_render_group* rg, Entity* e);
@ -49,9 +52,5 @@ void rgDraw(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
glm::mat4 view_matrix, glm::mat4 projection_matrix, glm::mat4 view_matrix, glm::mat4 projection_matrix,
glm::vec3 light_position, GLuint light_id, bool update_vertex_data = false); glm::vec3 light_position, GLuint light_id, bool update_vertex_data = false);
void rgDrawIndexed(gl_render_group* rg, GLenum draw_mode, glm::mat4 model_matrix,
glm::mat4 view_matrix, glm::mat4 projection_matrix,
glm::vec3 light_position, GLuint light_id);
void rgFree(gl_render_group* rg); void rgFree(gl_render_group* rg);

101
src/renderer.cpp
Unescape View File

@ -355,72 +355,68 @@ fillHexLineBuffer(GLfloat buf[], int len, std::vector<hex_info>* hexes)
} }
bool bool
createScene(std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count) initHexGridBuffers(std::vector<hex_info>* hexes)
{ {
initMatrices(PROJ_TYPE);
// Vertex Data
// TODO: index duplicate vertices // TODO: index duplicate vertices
// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-9-vbo-indexing/
int hex_count = (int) hexes->size();
// 6 triangles * 3 vertices per triangle * 3 floats per vertex = 54 // 6 triangles * 3 vertices per triangle * 3 floats per vertex = 54
int vbuf_len = hex_count * 6 * 3 * 3; uint vbuf_len = hexes->size() * 6 * 3 * 3;
uint line_vertices_per_hex = 6 * 2; // 12 vertices since we're using line segments atm
uint line_buf_len = hexes->size() * line_vertices_per_hex * 3; // 3 floats per vertex
// TODO: surely there's a way to use indexed drawing for line vertices eg) line_loop gl_buffer& vbuf = * rgInitGLBuffer(&g_filled_hex_render_group->vertex_buffer, vbuf_len);
// and still use one buffer for multiple shapes/paths gldrawarraysintanced?, gldrawelements? gl_buffer& cbuf = * rgInitGLBuffer(&g_filled_hex_render_group->color_buffer, vbuf_len);
// https://gamedev.stackexchange.com/questions/104310/opengl-4-5-primitive-restart-vs-base-index gl_buffer& normal_buf = * rgInitGLBuffer(&g_filled_hex_render_group->normal_buffer, vbuf_len);
int line_vertices_per_hex = 6 * 2; // 12 vertices since we're using line segments atm gl_buffer& line_buf = * rgInitGLBuffer(&g_hex_line_render_group->vertex_buffer, line_buf_len);
int line_buf_len = hexes->size() * line_vertices_per_hex * 3; // 3 floats per vertex
// temporary buffers if (!vbuf.buffer || !cbuf.buffer || !line_buf.buffer || !normal_buf.buffer)
GLfloat* vbuf = (GLfloat*) std::calloc(vbuf_len, sizeof(GLfloat)); return false;
GLfloat* cbuf = (GLfloat*) std::calloc(vbuf_len, sizeof(GLfloat));
GLfloat* line_buf = (GLfloat*) std::calloc(vbuf_len, sizeof(GLfloat));
for (int i = 0; i < hex_count; i++)
fillTriangleBufferFromHex(vbuf, 54 * i, (*hexes)[i]);
for (uint i = 0; i < hexes->size(); i++)
fillTriangleBufferFromHex(vbuf.buffer, 54 * i, (*hexes)[i]);
rgInitGLBufferObject(&g_filled_hex_render_group->vertex_buffer, vbuf_len, rgSendBufferToGL(&vbuf, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, vbuf);
// color data for hex vertices // color data for hex vertices
rgFillColorBuffer(cbuf, vbuf_len, hexes); rgFillColorBuffer(cbuf.buffer, vbuf_len, hexes);
rgInitGLBufferObject(&g_filled_hex_render_group->color_buffer, vbuf_len, rgSendBufferToGL(&cbuf, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, cbuf);
// cheat at vertex normals since all hexes lay flat on z-axis // cheat at vertex normals since all hexes lay flat on z-axis
GLfloat* normal_buf = (GLfloat*) std::calloc(vbuf_len, sizeof(GLfloat)); for (uint i = 0; i < vbuf_len; i += 3) {
for (int i = 0; i < vbuf_len; i += 3) { normal_buf.buffer[i] = 0;
normal_buf[i] = 0; normal_buf.buffer[i + 1] = 0;
normal_buf[i + 1] = 0; normal_buf.buffer[i + 2] = 1;
normal_buf[i + 2] = 1;
} }
rgInitGLBufferObject(&g_filled_hex_render_group->vertex_normals, vbuf_len, rgSendBufferToGL(&normal_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
GL_STATIC_DRAW, GL_ARRAY_BUFFER, normal_buf);
g_filled_hex_render_group->use_normals = true; g_filled_hex_render_group->use_normals = true;
// hex line vertex data // hex line vertex data
fillHexLineBuffer(line_buf, line_buf_len, hexes); fillHexLineBuffer(line_buf.buffer, line_buf_len, hexes);
rgInitGLBufferObject(&g_hex_line_render_group->vertex_buffer, line_buf_len, g_hex_line_render_group->vertex_buffer.buffer_len = line_buf_len;
GL_STATIC_DRAW, GL_ARRAY_BUFFER, line_buf); rgSendBufferToGL(&line_buf, GL_STATIC_DRAW, GL_ARRAY_BUFFER);
// TODO: add a color buffer to hex_line and debug render groups to re-use // TODO: add a color buffer to hex_line and debug render groups to re-use
// fragment shaders and simplify draw rgDraw() // fragment shaders and simplify draw rgDraw()
return true;
}
// free temporary buffers bool
std::free(vbuf); createScene(std::vector<hex_info>* hexes, Entity* entities, uint32 entity_count)
std::free(cbuf); {
std::free(line_buf); initMatrices(PROJ_TYPE);
std::free(normal_buf);
vbuf = cbuf = line_buf = normal_buf = nullptr; if (!initHexGridBuffers(hexes))
return false;
// debug draw vertexes // debug draw vertexes
int len = 4 * 3; // 4 vertices, 3 floats per vertex
rgInitGLBufferObject(&g_debug_render_group->vertex_buffer, len, rgInitGLBuffer(&g_debug_render_group->vertex_buffer, 4 * 3); // 4 vertices * 3 floats per vertex
GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER, 0);
if (!g_debug_render_group->vertex_buffer.buffer)
return false;
rgSendBufferToGL(&g_debug_render_group->vertex_buffer, GL_DYNAMIC_DRAW, GL_ARRAY_BUFFER);
// entities // entities
@ -553,7 +549,7 @@ renderFrame(std::vector<hex_info> *hexes, Entity* entities, uint32 entity_count)
// every frame through rgDrawIndexed() // every frame through rgDrawIndexed()
// entities // entities
for (uint i = 0; i < entity_count; i++) { for (uint i = 0; i < entity_count; i++) {
rgDrawIndexed( rgDraw(
g_entity_render_group, GL_TRIANGLES, g_entity_render_group, GL_TRIANGLES,
entities[i].mesh->model_transform, m_view, m_projection, entities[i].mesh->model_transform, m_view, m_projection,
g_test_light.position, g_test_light.light_ID g_test_light.position, g_test_light.light_ID
@ -565,19 +561,14 @@ void
renderDebug(std::vector<Point> &vertices) renderDebug(std::vector<Point> &vertices)
{ {
// TODO: indexed line drawing // TODO: indexed line drawing
real64 buf[4 * 3] = {
vertices[0].x, vertices[0].y, 0,
vertices[1].x, vertices[1].y, 0,
vertices[2].x, vertices[2].y, 0,
vertices[3].x, vertices[3].y, 0,
};
// copy vertexes to render group // copy vertexes to render group
gl_render_group* rg = g_debug_render_group; GLfloat* buf = g_debug_render_group->vertex_buffer.buffer;
for (int i = 0; i < 12; i++) buf[0] = vertices[0].x; buf[1] = vertices[0].y; buf[2] = 0;
rg->vertex_buffer.buffer[i] = buf[i]; buf[3] = vertices[1].x; buf[4] = vertices[1].y; buf[2] = 0;
buf[6] = vertices[2].x; buf[7] = vertices[2].y; buf[8] = 0;
buf[9] = vertices[3].x; buf[10] = vertices[3].y; buf[11] = 0;
rgDraw(rg, GL_LINE_LOOP, g_scene_matrices.model, g_scene_matrices.view, rgDraw(g_debug_render_group, GL_LINE_LOOP, g_scene_matrices.model, g_scene_matrices.view,
g_scene_matrices.projection, g_test_light.position, g_test_light.light_ID, true); g_scene_matrices.projection, g_test_light.position, g_test_light.light_ID, true);
} }

2
src/util.cpp
Unescape View File

@ -2,7 +2,7 @@
#include <cstdlib> #include <cstdlib>
#include <cstdio> #include <cstdio>
#include "aixlog.hpp" //#include "aixlog.hpp"
#include "util.h" #include "util.h"

10
src/util.h
Unescape View File

@ -6,6 +6,7 @@
typedef float real32; typedef float real32;
typedef float GLfloat;
typedef double real64; typedef double real64;
typedef int32_t bool32; typedef int32_t bool32;
typedef int32_t int32; typedef int32_t int32;
@ -64,6 +65,15 @@ SafeTruncateToInt32(int64 val)
return (int32) val; return (int32) val;
} }
inline void
utilConvertColor(GLfloat buf[3], uint32 color)
{
// NOTE: not using the alpha values
buf[0] = (GLfloat) ((color >> 24) & 0xFF) / (GLfloat) 255;
buf[1] = (GLfloat) ((color >> 16) & 0xFF) / (GLfloat) 255;
buf[2] = (GLfloat) ((color >> 8) & 0xFF) / (GLfloat) 255;
}
char * utilDumpTextFile(const char* filename); char * utilDumpTextFile(const char* filename);
void utilSafeFree(void* mem); void utilSafeFree(void* mem);

Write Preview
Loading…
Cancel
Save