iamgreaser/buldthensnip
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
buldthensnip/src/gl/render.c

1157 lines
40 KiB
C
Raw Blame History

/*
This file is part of Iceball.
Iceball is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Iceball is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Iceball. If not, see <http://www.gnu.org/licenses/>.
*/
#include "common.h"
const GLfloat mtx_baseproj[16] = {
-1, 0, 0, 0,
0,-1, 0, 0,
0, 0, 1, 1,
0, 0,-0.1, 0,
};
const GLfloat vfinf_cube[3*6] = {
0, 1, 0, 0, 0, 1,
0, 0, 1, 1, 0, 0,
1, 0, 0, 0, 1, 0,
};
#if 0
#define DEBUG_INVERT_DRAW_DIR
#endif
#if 0
#define DEBUG_SHOW_TOP_BOTTOM
#define DEBUG_HIDE_MAIN
#endif
#define CUBESUX_MARKER 20
#define RAYC_MAX ((int)((FOG_MAX_DISTANCE+1)*(FOG_MAX_DISTANCE+1)*8+10))
#define DF_NX 0x01
#define DF_NY 0x02
#define DF_NZ 0x04
#define DF_PX 0x08
#define DF_PY 0x10
#define DF_PZ 0x20
#define DF_SPREAD 0x3F
enum
{
CM_NX = 0,
CM_NY,
CM_NZ,
CM_PX,
CM_PY,
CM_PZ,
CM_MAX
};
int cam_shading_map[6][4] = {
{CM_PZ, CM_NZ, CM_PY, CM_NY},
{CM_NX, CM_PX, CM_NZ, CM_PZ},
{CM_NX, CM_PX, CM_PY, CM_NY},
{CM_NZ, CM_PZ, CM_PY, CM_NY},
{CM_PX, CM_NX, CM_PZ, CM_NZ},
{CM_PX, CM_NX, CM_PY, CM_NY},
};
float fog_distance = FOG_INIT_DISTANCE;
uint32_t fog_color = 0xD0E0FF;
uint32_t cam_shading[6] = {
0x000C0, 0x000A0, 0x000D0, 0x000E0, 0x00FF, 0x000D0,
};
void render_pillar(map_t *map, map_chunk_t *chunk, int x, int z);
/*
* REFERENCE IMPLEMENTATION
*
*/
/* custom mod function that handles negative numbers */
inline int render_mod ( int x , int y )
{
return x >= 0 ? x % y : y - 1 - ((-x-1) % y) ;
}
uint32_t render_shade(uint32_t color, int face)
{
uint32_t fc = cam_shading[face];
return (((((color&0x00FF00FF)*fc)>>8)&0x00FF00FF))
|((((((color>>8)&0x00FF00FF)*fc))&0xFF00FF00))|0x01000000;
}
GLfloat render_darken_color(GLfloat original_color, GLfloat factor)
{
return original_color + (factor * (0.0f - original_color)) / 1.0f;
}
int render_map_get_block_at(map_t *map, int x, int y, int z)
{
int i;
uint8_t *data = NULL;
if (map == NULL)
return 0;
if (y < 0)
return 0;
data = map->pillars[(z&(map->zlen-1))*(map->xlen)+(x&(map->xlen-1))];
data += 4;
for(;;)
{
if (y>=data[1] && y<=data[2])
return 1;
if (y>=data[3] && y<data[1])
return 0;
if(data[0] == 0)
return 1;
data += 4*(int)data[0];
}
return 0;
}
GLfloat render_get_average_light(map_t *map, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3, int x4, int y4, int z4)
{
GLfloat average = (
render_map_get_block_at(map, x1, y1, z1)
+ render_map_get_block_at(map, x2, y2, z2)
+ render_map_get_block_at(map, x3, y3, z3)
+ render_map_get_block_at(map, x4, y4, z4)
) / 4.0f;
return average;
}
inline int render_visible_chunks_array_offset(map_t *map, int x, int z)
{
return z * (int) map->visible_chunks_len + x;
}
void render_untesselate_visible_chunk(map_chunk_t *chunk)
{
if (chunk == NULL)
return;
if (chunk->vbo_arr != NULL)
{
free(chunk->vbo_arr);
chunk->vbo_arr = NULL;
}
if (chunk->vbo != 0)
{
glDeleteBuffers(1, &(chunk->vbo));
chunk->vbo = 0;
}
chunk->vbo_dirty = 0;
chunk->vbo_arr_len = 0;
}
void render_free_visible_chunk(map_chunk_t *chunk)
{
if (chunk == NULL)
return;
render_untesselate_visible_chunk(chunk);
chunk->cx = 0;
chunk->cz = 0;
}
void render_free_visible_chunks(map_t *map)
{
int x, z;
if(map == NULL || map->visible_chunks_arr == NULL)
return;
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
render_free_visible_chunk(&map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)]);
}
}
}
void render_init_visible_chunks(map_t *map, int starting_chunk_coordinate_x, int starting_chunk_coordinate_z)
{
/*
example for gl_visible_chunks = 9
- array size would be 3x3
- virtual center of the circular array would be [1,1] at init
0 1 2
+---+---+---+
0 | | | |
+---#####---+
1 | # # |
+---#####---+
2 | | | |
+---+---+---+
*/
int x, z;
/* chunk coordinates */
int cx, cz;
if (map == NULL)
return;
if (map->visible_chunks_arr != NULL)
{
render_free_visible_chunks(map);
free(map->visible_chunks_arr);
map->visible_chunks_arr = NULL;
}
map->visible_chunks_len = ((((int)fog_distance)+(gl_chunk_size+1)/2)/gl_chunk_size)*2+1;
map->visible_chunks_arr = (map_chunk_t *) malloc(map->visible_chunks_len * map->visible_chunks_len * sizeof(map_chunk_t));
/* check if the visible chunks array has been allocated properly */
if(map->visible_chunks_arr == NULL)
{
fprintf(stderr, "render_init_visible_chunks: could not allocate visible chunks array\n");
return;
}
map->visible_chunks_vcenter_cx = starting_chunk_coordinate_x;
map->visible_chunks_vcenter_cz = starting_chunk_coordinate_z;
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
cx = starting_chunk_coordinate_x - (int) map->visible_chunks_len/2 + x;
cz = starting_chunk_coordinate_z - (int) map->visible_chunks_len/2 + z;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].cx = cx;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].cz = cz;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo = 0;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo_dirty = 1;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo_arr_len = 0;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo_arr = NULL;
}
}
map->visible_chunks_vcenter_x = (int) map->visible_chunks_len/2;
map->visible_chunks_vcenter_z = (int) map->visible_chunks_len/2;
}
void render_shift_visible_chunks(map_t *map, int camera_chunk_coordinate_x, int camera_chunk_coordinate_z)
{
int position_shift_x, position_shift_z;
int offset_x, offset_z;
int index_x, index_z;
int x, z;
if(map == NULL || map->visible_chunks_arr == NULL)
return;
position_shift_x = camera_chunk_coordinate_x - map->visible_chunks_vcenter_cx;
position_shift_z = camera_chunk_coordinate_z - map->visible_chunks_vcenter_cz;
/* if position is the same, nothing to do */
if (position_shift_x == 0 && position_shift_z == 0)
return;
/* setting the new virtual center of the circular array */
map->visible_chunks_vcenter_x = render_mod(map->visible_chunks_vcenter_x + position_shift_x, (int) map->visible_chunks_len);
map->visible_chunks_vcenter_z = render_mod(map->visible_chunks_vcenter_z + position_shift_z, (int) map->visible_chunks_len);
/* setting the chunk coordinates of the virtual center of the circular array */
map->visible_chunks_vcenter_cx = camera_chunk_coordinate_x;
map->visible_chunks_vcenter_cz = camera_chunk_coordinate_z;
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
offset_x = x - ((int) map->visible_chunks_len- 1)/2;
offset_z = z - ((int) map->visible_chunks_len- 1)/2;
index_x = render_mod(map->visible_chunks_vcenter_x + offset_x, (int) map->visible_chunks_len);
index_z = render_mod(map->visible_chunks_vcenter_z + offset_z, (int) map->visible_chunks_len);
/* untesselate chunks not visible anymore */
if (map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].cx != map->visible_chunks_vcenter_cx + offset_x
|| map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].cz != map->visible_chunks_vcenter_cz + offset_z)
{
render_free_visible_chunk(&map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)]);
}
/* add chunks that are visible */
if (map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].vbo_arr == NULL)
{
map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].cx = map->visible_chunks_vcenter_cx + offset_x;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].cz = map->visible_chunks_vcenter_cz + offset_z;
map->visible_chunks_arr[render_visible_chunks_array_offset(map, index_x, index_z)].vbo_dirty = 1;
}
}
}
}
void render_map_visible_chunks_draw(map_t *map, float fx, float fy, float fz, float cx, float cy, float cz)
{
int x, z;
if(map == NULL || map->visible_chunks_arr == NULL)
return;
float normfy = fy / sqrtf(fx*fx + fy*fy + fz*fz);
float emax = 0.7f * sqrtf(1.0 - normfy*normfy);
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
map_chunk_t *chunk = &(map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)]);
if (chunk->vbo_arr_len > 0)
{
if(gl_frustum_cull)
{
// calculate first corner
float px00 = chunk->cx*gl_chunk_size - cx;
float pz00 = chunk->cz*gl_chunk_size - cz;
// calculate subsequent corners
float px01 = px00 + gl_chunk_size;
float pz01 = pz00;
float px10 = px00;
float pz10 = pz00 + gl_chunk_size;
float px11 = px01;
float pz11 = pz01 + gl_chunk_size;
//printf("%f %f -> %f %f\n", px00, pz00, px11, pz11);
// get lengths of corners
float d00 = sqrtf(px00 * px00 + pz00 * pz00);
float d10 = sqrtf(px10 * px10 + pz10 * pz10);
float d01 = sqrtf(px01 * px01 + pz01 * pz01);
float d11 = sqrtf(px11 * px11 + pz11 * pz11);
// normalise corners
px00 /= d00; pz00 /= d00;
px10 /= d10; pz10 /= d10;
px01 /= d01; pz01 /= d01;
px11 /= d11; pz11 /= d11;
// get normalised 2D forward vector
float f2d = sqrtf(fx*fx + fz*fz);
float f2x = fx/f2d;
float f2z = fz/f2d;
// get dot products against forward vector
float e00 = px00 * f2x + pz00 * f2z;
float e10 = px10 * f2x + pz10 * f2z;
float e01 = px01 * f2x + pz01 * f2z;
float e11 = px11 * f2x + pz11 * f2z;
// frustum cull provided chunk isn't TOO close
if(d00/2 >= gl_chunk_size && d01/2 >= gl_chunk_size && d10/2 >= gl_chunk_size && d11/2 >= gl_chunk_size)
if(e00 < emax && e01 < emax && e10 < emax && e11 < emax)
continue;
}
// select pointers
if (chunk->vbo == 0)
{
glVertexPointer(3, GL_FLOAT, sizeof(float)*6, chunk->vbo_arr);
glColorPointer(3, GL_FLOAT, sizeof(float)*6, chunk->vbo_arr+3);
} else {
glBindBuffer(GL_ARRAY_BUFFER, chunk->vbo);
glVertexPointer(3, GL_FLOAT, sizeof(float)*6, (void *)(0));
glColorPointer(3, GL_FLOAT, sizeof(float)*6, (void *)(0 + sizeof(float)*3));
}
// draw
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_QUADS, 0, chunk->vbo_arr_len);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
// unbind buffer
if (chunk->vbo != 0)
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}
}
}
int render_map_visible_chunks_count_dirty(map_t *map)
{
int x, z;
int dirty_chunks_count = 0;
if(map == NULL || map->visible_chunks_arr == NULL)
return 0;
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
if (map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo_dirty)
{
dirty_chunks_count++;
}
}
}
return dirty_chunks_count;
}
void render_map_tesselate_visible_chunks(map_t *map, int camx, int camz)
{
int x, z, i, vx, vz;
int bx, bz;
/* pillar coords */
int px, pz;
map_chunk_t *chunk;
int chunks_tesselated = 0;
if(map == NULL || map->visible_chunks_arr == NULL)
return;
bx = bz = 0;
vx = 1; vz = 0;
for(i = 0; i < map->visible_chunks_len * map->visible_chunks_len; i++)
{
x = render_mod(bx + camx + map->visible_chunks_len/2, map->visible_chunks_len);
z = render_mod(bz + camz + map->visible_chunks_len/2, map->visible_chunks_len);
chunk = &map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)];
if (chunks_tesselated >= gl_chunks_tesselated_per_frame)
return;
if (chunk->vbo_dirty)
{
render_untesselate_visible_chunk(chunk);
for (px = 0; px < gl_chunk_size; px++)
{
for (pz = 0; pz < gl_chunk_size; pz++)
{
render_pillar(map, chunk, chunk->cx * gl_chunk_size + px, chunk->cz * gl_chunk_size + pz);
}
}
if(chunk->vbo == 0 && GL_ARB_vertex_buffer_object && gl_use_vbo)
glGenBuffers(1, &(chunk->vbo));
if(chunk->vbo != 0)
{
glBindBuffer(GL_ARRAY_BUFFER, chunk->vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*6*chunk->vbo_arr_len, chunk->vbo_arr, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
chunk->vbo_dirty = 0;
chunks_tesselated++;
}
// rotate around in a spiral
bx += vx;
bz += vz;
if(vz == 0
? (vx == 1 ? bx > bz : bx <= bz )
: (vz == 1 ? bz >= -bx : bz <= -bx ))
{
int t = vx;
vx = vz;
vz = -t;
}
}
}
void render_map_mark_chunks_as_dirty(map_t *map, int pillar_x, int pillar_z)
{
int x, z;
int chunk_x, chunk_z;
int neighbor_chunk_x, neighbor_chunk_z;
map_chunk_t *neighbor_chunk = NULL;
chunk_x = pillar_x/gl_chunk_size;
chunk_z = pillar_z/gl_chunk_size;
if(map == NULL || map->visible_chunks_arr == NULL)
return;
for (x = 0; x < (int) map->visible_chunks_len; x++)
{
for (z = 0; z < (int) map->visible_chunks_len; z++)
{
if (map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].cx == chunk_x && map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].cz == chunk_z)
{
map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)].vbo_dirty = 1;
/* If pillar coords are between two chunks, we need to update the neighbor chunks as well */
if (render_mod(pillar_x, gl_chunk_size) == 0)
{
neighbor_chunk_x = render_mod(x - 1, (int) map->visible_chunks_len);
neighbor_chunk_z = z;
neighbor_chunk = &map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)];
if (neighbor_chunk->cx == chunk_x - 1 && neighbor_chunk->cz == chunk_z)
{
neighbor_chunk->vbo_dirty = 1;
}
} else if (render_mod(pillar_x, gl_chunk_size) == gl_chunk_size-1)
{
neighbor_chunk_x = render_mod(x + 1, (int) map->visible_chunks_len);
neighbor_chunk_z = z;
neighbor_chunk = &map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)];
if (neighbor_chunk->cx == chunk_x + 1 && neighbor_chunk->cz == chunk_z)
{
neighbor_chunk->vbo_dirty = 1;
}
}
if (render_mod(pillar_z, gl_chunk_size) == 0)
{
neighbor_chunk_x = x;
neighbor_chunk_z = render_mod(z - 1, (int) map->visible_chunks_len);
neighbor_chunk = &map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)];
if (neighbor_chunk->cx == chunk_x && neighbor_chunk->cz == chunk_z - 1)
{
neighbor_chunk->vbo_dirty = 1;
}
} else if (render_mod(pillar_z, gl_chunk_size) == gl_chunk_size-1)
{
neighbor_chunk_x = x;
neighbor_chunk_z = render_mod(z + 1, (int) map->visible_chunks_len);
neighbor_chunk = &map->visible_chunks_arr[render_visible_chunks_array_offset(map, x, z)];
if (neighbor_chunk->cx == chunk_x && neighbor_chunk->cz == chunk_z + 1)
{
neighbor_chunk->vbo_dirty = 1;
}
}
return;
}
}
}
}
void render_update_vbo(float **arr, int *len, int *max, int newlen)
{
int xlen = 0;
if(*arr == NULL)
{
xlen = newlen + 10;
} else if(newlen <= *max) {
return;
} else {
xlen = ((*max)*3)/2+1;
if(xlen < newlen)
xlen = newlen + 10;
}
*arr = (float*)realloc(*arr, xlen*sizeof(float)*6);
*max = xlen;
}
void render_gl_cube_pmf(model_bone_t *bone, float x, float y, float z, float r, float g, float b, float rad)
{
int i;
float ua,ub,uc;
float va,vb,vc;
render_update_vbo(&(bone->vbo_arr), &(bone->vbo_arr_len), &(bone->vbo_arr_max), bone->vbo_arr_len+4*6);
float *arr = bone->vbo_arr;
arr += bone->vbo_arr_len*6;
bone->vbo_arr_len += 4*6;
for(i = 0; i < 3; i++)
{
float s2 = ((int)cam_shading[i+0])/255.0f;
float s1 = ((int)cam_shading[i+3])/255.0f;
float cr,cg,cb;
ua = vfinf_cube[i*6+0];
ub = vfinf_cube[i*6+1];
uc = vfinf_cube[i*6+2];
va = vfinf_cube[i*6+3];
vb = vfinf_cube[i*6+4];
vc = vfinf_cube[i*6+5];
#define ARR_ADD(vx,vy,vz) \
*(arr++) = vx; *(arr++) = vy; *(arr++) = vz; \
*(arr++) = cr; *(arr++) = cg; *(arr++) = cb;
/* Quad 1 */
cr = r*s1; cg = g*s1, cb = b*s1;
ARR_ADD(x,y,z);
ARR_ADD(x+rad*ua,y+rad*ub,z+rad*uc);
ARR_ADD(x+rad*(ua+va),y+rad*(ub+vb),z+rad*(uc+vc));
ARR_ADD(x+rad*va,y+rad*vb,z+rad*vc);
/* Quad 2 */
cr = r*s2; cg = g*s2, cb = b*s2;
ARR_ADD(x+rad,y+rad,z+rad);
ARR_ADD(x+rad*(1-va),y+rad*(1-vb),z+rad*(1-vc));
ARR_ADD(x+rad*(1-ua-va),y+rad*(1-ub-vb),z+rad*(1-uc-vc));
ARR_ADD(x+rad*(1-ua),y+rad*(1-ub),z+rad*(1-uc));
#undef ARR_ADD
}
}
void render_gl_cube_map(map_t *map, map_chunk_t *chunk, float x, float y, float z, float r, float g, float b, float rad)
{
int i;
float ua,ub,uc;
float va,vb,vc;
float average_light_vertex1, average_light_vertex2, average_light_vertex3, average_light_vertex4;
float *arr = chunk->vbo_arr;
/* Quads rendering explained (sort of)
'o' in drawings represents the vertex at origin
'+' a vertex
'1' digits represents vertex number
i = 0 | i = 1 | i = 2
----- | ----- | -----
| |
Quad 1 (left) Quad 2 (right) | Quad 1 (top) Quad 2 (bottom) | Quad 1 (back) Quad 2 (front)
| |
1 3 | 1 4 | 1 2
+-- x o....... o......+ | +-- x o------+ o....... | +-- x o------+ o.......
/| 4 /| .. .. 4 /| | /| /. /. .. .. | /| .| .| 3 .. 2.
z y +.|..... . .......+ | |z y +------+ . ........ . |z y ..|..... | +------+ .
| +....... . .....|.+ | 2. ......3. . +------+ | . +------+ | .....|..
|/ 2 .. .. |/ 2 | .. .. ./ 3 ./ 4 | .. 4 .. 3 |. |/
+....... .......+ | ........ +------+ | ........ +------+
3 1 | 2 1 | 4 1
| |
ua = 0.0 va = 0.0 | ua = 0.0 va = 1.0 | ua = 1.0 va = 0.0
ub = 1.0 vb = 0.0 | ub = 0.0 vb = 0.0 | ub = 0.0 vb = 1.0
uc = 0.0 vc = 1.0 | uc = 1.0 vc = 0.0 | uc = 0.0 vc = 0.0
| |
| |
Neighbor to check for face drawing toggle | Neighbor to check for face drawing toggle | Neighbor to check for face drawing toggle
| |
Quad1 Quad2 | Quad1 Quad2 | Quad1 Quad2
x - 1 x + 1 | y - 1 y + 1 | z - 1 z + 1
| |
| |
Neighbors to check for light average | Neighbors to check for light average | Neighbors to check for light average
| |
Left Right | Top Bottom | Back Front
---- ----- | ------ --- | ---- -----
| |
Vertex1 Vertex1 | Vertex1 Vertex1 | Vertex1 Vertex1
x-1, y, z x+1, y, z | x, y-1, z x, y+1, z | x, y, z-1 x, y, z+1
x-1, y-1, z x+1, y+1, z | x-1, y-1, z x+1, y+1, z | x-1, y, z-1 x+1, y, z+1
x-1, y-1, z-1 x+1, y+1, z+1 | x-1, y-1, z-1 x+1 y+1, z+1 | x-1, y-1, z-1 x+1, y+1, z+1
x-1, y, z-1 x+1, y, z+1 | x, y-1, z-1 x, y+1, z+1 | x, y-1, z-1 x, y+1, z+1
| |
Vertex2 Vertex2 | Vertex2 Vertex2 | Vertex2 Vertex2
x-1, y, z x+1, y, z | x, y-1, z x, y+1, z | x, y, z-1 x, y, z+1
x-1, y+1, z x+1, y+1, z | x-1, y-1, z x-1, y+1, z | x+1, y, z-1 x+1, y, z+1
x-1, y+1, z-1 x+1, y+1, z-1 | x-1, y-1, z+1 x-1, y+1, z+1 | x+1, y-1, z-1 x+1, y-1, z+1
x-1, y, z-1 x+1, y, z-1 | x, y-1, z+1 x, y+1, z+1 | x, y-1, z-1 x, y-1, z+1
| |
Vertex3 Vertex3 | Vertex3 Vertex3 | Vertex3 Vertex3
x-1, y, z x+1, y, z | x, y-1, z x, y+1, z | x, y, z-1 x, y, z+1
x-1, y+1, z x+1, y-1, z | x+1, y-1, z x-1, y+1, z | x+1, y, z-1 x-1, y, z+1
x-1, y+1, z+1 x+1, y-1, z-1 | x+1, y-1, z+1 x-1, y+1, z-1 | x+1, y+1, z-1 x-1, y-1, z+1
x-1, y, z+1 x+1, y, z-1 | x, y-1, z+1 x, y+1, z-1 | x, y+1, z-1 x, y-1, z+1
| |
Vertex4 Vertex4 | Vertex4 Vertex4 | Vertex4 Vertex4
x-1, y, z x+1, y, z | x, y-1, z x, y+1 z | x, y, z-1 x, y, z+1
x-1, y-1, z x+1, y-1, z | x+1, y-1, z x+1, y+1 z | x-1, y, z-1 x-1, y, z+1
x-1, y-1, z+1 x+1, y-1, z+1 | x+1, y-1, z-1 x+1, y+1 z-1 | x-1, y+1, z-1 x-1, y+1, z+1
x-1, y , z+1 x+1, y, z+1 | x, y-1, z-1 x, y+1 z-1 | x, y+1, z-1 x, y+1, z+1
Neighbors to check for face drawing :
Quad 1 Quad 2
------ ------
x - ub, y - uc, z - ua x + vc, y + va, z + vb
Generic coordinates formula (<=> regardless of i value) to check for each vertex (holy moly, it seems to be working ^^) :
Quad 1 Quad 2
------ ------
V1 V1
x-ub, y-uc, z-ua x+vc, y+va, z+vb
x-1, y-1+ua, z-ua x+1, y+1-vb, z+vb
x-1, y-1, z-1 x+1, y+1, z+1
x-ub, y-1+ub, z-1 x+vc, y+1-vc, z+1
V2 V2
x-ub, y-uc, z-ua x+vc, y+va, z+vb
x-1+2*ua, y+(1-ua)-2*uc, z-ua x+1-2*va, y+1-vb, z+vb
x-1+2*ua, y-1+2*ub, z-1+2*uc x+1-2*va, y+1-2*vb, z+1-2*vc
x-ub, y-1+ub, z-1+2*uc x+vc, y+(1-vc)-2*vb, z+1-2*vc
V3 V3
x-ub, y-uc, z-ua x+vc, y+va, z+vb
x+1-2*ub, y+(1-ua)-2*uc, z-ua x-1+2*vc, y+(1-vb)-2*vc, z+vb
x+1-2*ub, y+1-2*uc, z+1-2*ua x-1+2*vc, y-1+2*va, z-1+2*vb
x-ub, y+(1-ub)-2*uc, z+1-2*ua x+vc, y+(1-vc)-2*vb, z-1+2*vb
V4 V4
x-ub, y-uc, z-ua x+vc, y+va, z+vb
x-1+2*uc, y-1+ua, z-ua x+1-2*vb, y+(1-vb)-2*vc, z+vb
x-1+2*uc, y-1+2*ua, z-1+2*ub x+1-2*vb, y+1-2*vc, z+1-2*va
x-ub, y+(1-ub)-2*uc, z-1+2*ub x+vc, y+1-vc, z+1-2*va
*/
for(i = 0; i < 3; i++)
{
ua = vfinf_cube[i*6+0];
ub = vfinf_cube[i*6+1];
uc = vfinf_cube[i*6+2];
va = vfinf_cube[i*6+3];
vb = vfinf_cube[i*6+4];
vc = vfinf_cube[i*6+5];
float s2 = ((int)cam_shading[i+0])/255.0f;
float s1 = ((int)cam_shading[i+3])/255.0f;
float cr,cg,cb;
#define ARR_ADD(vx,vy,vz) \
*(arr++) = vx; *(arr++) = vy; *(arr++) = vz; \
*(arr++) = cr; *(arr++) = cg; *(arr++) = cb;
/* check visibility of the face (is face exposed to air ?) */
if (render_map_get_block_at(map, x - ub, y - uc, z - ua) == 0)
{
render_update_vbo(&(chunk->vbo_arr), &(chunk->vbo_arr_len), &(chunk->vbo_arr_max), chunk->vbo_arr_len+4);
arr = chunk->vbo_arr;
arr += chunk->vbo_arr_len*6;
chunk->vbo_arr_len += 4;
if (screen_smooth_lighting)
{
average_light_vertex1 = render_get_average_light(
map,
x-ub, y-uc, z-ua,
x-1, y-1+ua, z-ua,
x-1, y-1, z-1,
x-ub, y-1+ub, z-1);
average_light_vertex2 = render_get_average_light(
map,
x-ub, y-uc, z-ua,
x-1+2*ua, y+(1-ua)-2*uc, z-ua,
x-1+2*ua, y-1+2*ub, z-1+2*uc,
x-ub, y-1+ub, z-1+2*uc);
average_light_vertex3 = render_get_average_light(
map,
x-ub, y-uc, z-ua,
x+1-2*ub, y+(1-ua)-2*uc, z-ua,
x+1-2*ub, y+1-2*uc, z+1-2*ua,
x-ub, y+(1-ub)-2*uc, z+1-2*ua);
average_light_vertex4 = render_get_average_light(
map,
x-ub, y-uc, z-ua,
x-1+2*uc, y-1+ua, z-ua,
x-1+2*uc, y-1+2*ua, z-1+2*ub,
x-ub, y+(1-ub)-2*uc, z-1+2*ub);
} else {
average_light_vertex1 = 0.0f;
average_light_vertex2 = 0.0f;
average_light_vertex3 = 0.0f;
average_light_vertex4 = 0.0f;
}
/* Check if the quad needs to be rotated (fix for ambient occlusion on sides) */
if (average_light_vertex1 + average_light_vertex3 > average_light_vertex2 + average_light_vertex4)
{
/* Quad 1 rotated */
/* vertex 2 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex2);
cg = render_darken_color(cg, average_light_vertex2);
cb = render_darken_color(cb, average_light_vertex2);
ARR_ADD(x+rad*ua,y+rad*ub,z+rad*uc);
/* vertex 3 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex3);
cg = render_darken_color(cg, average_light_vertex3);
cb = render_darken_color(cb, average_light_vertex3);
ARR_ADD(x+rad*(ua+va),y+rad*(ub+vb),z+rad*(uc+vc));
/* vertex 4 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex4);
cg = render_darken_color(cg, average_light_vertex4);
cb = render_darken_color(cb, average_light_vertex4);
ARR_ADD(x+rad*va,y+rad*vb,z+rad*vc);
/* vertex 1 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex1);
cg = render_darken_color(cg, average_light_vertex1);
cb = render_darken_color(cb, average_light_vertex1);
ARR_ADD(x,y,z);
} else {
/* Quad 1 normal */
/* vertex 1 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex1);
cg = render_darken_color(cg, average_light_vertex1);
cb = render_darken_color(cb, average_light_vertex1);
ARR_ADD(x,y,z);
/* vertex 2 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex2);
cg = render_darken_color(cg, average_light_vertex2);
cb = render_darken_color(cb, average_light_vertex2);
ARR_ADD(x+rad*ua,y+rad*ub,z+rad*uc);
/* vertex 3 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex3);
cg = render_darken_color(cg, average_light_vertex3);
cb = render_darken_color(cb, average_light_vertex3);
ARR_ADD(x+rad*(ua+va),y+rad*(ub+vb),z+rad*(uc+vc));
/* vertex 4 */
cr = r*s1; cg = g*s1, cb = b*s1;
cr = render_darken_color(cr, average_light_vertex4);
cg = render_darken_color(cg, average_light_vertex4);
cb = render_darken_color(cb, average_light_vertex4);
ARR_ADD(x+rad*va,y+rad*vb,z+rad*vc);
}
}
/* check visibility of the face (is face exposed to air ?) */
if (render_map_get_block_at(map, x + vc, y + va, z + vb) == 0)
{
render_update_vbo(&(chunk->vbo_arr), &(chunk->vbo_arr_len), &(chunk->vbo_arr_max), chunk->vbo_arr_len+4);
arr = chunk->vbo_arr;
arr += chunk->vbo_arr_len*6;
chunk->vbo_arr_len += 4;
if (screen_smooth_lighting)
{
average_light_vertex1 = render_get_average_light(
map,
x+vc, y+va, z+vb,
x+1, y+1-vb, z+vb,
x+1, y+1, z+1,
x+vc, y+1-vc, z+1);
average_light_vertex2 = render_get_average_light(
map,
x+vc, y+va, z+vb,
x+1-2*va, y+1-vb, z+vb,
x+1-2*va, y+1-2*vb, z+1-2*vc,
x+vc, y+(1-vc)-2*vb, z+1-2*vc);
average_light_vertex3 = render_get_average_light(
map,
x+vc, y+va, z+vb,
x-1+2*vc, y+(1-vb)-2*vc, z+vb,
x-1+2*vc, y-1+2*va, z-1+2*vb,
x+vc, y+(1-vc)-2*vb, z-1+2*vb);
average_light_vertex4 = render_get_average_light(
map,
x+vc, y+va, z+vb,
x+1-2*vb, y+(1-vb)-2*vc, z+vb,
x+1-2*vb, y+1-2*vc, z+1-2*va,
x+vc, y+1-vc, z+1-2*va);
} else {
average_light_vertex1 = 0.0f;
average_light_vertex2 = 0.0f;
average_light_vertex3 = 0.0f;
average_light_vertex4 = 0.0f;
}
/* Check if the quad needs to be rotated (fix for ambient occlusion on sides) */
if (average_light_vertex1 + average_light_vertex3 > average_light_vertex2 + average_light_vertex4)
{
/* Quad 2 rotated */
/* vertex 2 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex2);
cg = render_darken_color(cg, average_light_vertex2);
cb = render_darken_color(cb, average_light_vertex2);
ARR_ADD(x+rad*(1-va),y+rad*(1-vb),z+rad*(1-vc));
/* vertex 3 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex3);
cg = render_darken_color(cg, average_light_vertex3);
cb = render_darken_color(cb, average_light_vertex3);
ARR_ADD(x+rad*(1-ua-va),y+rad*(1-ub-vb),z+rad*(1-uc-vc));
/* vertex 4 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex4);
cg = render_darken_color(cg, average_light_vertex4);
cb = render_darken_color(cb, average_light_vertex4);
ARR_ADD(x+rad*(1-ua),y+rad*(1-ub),z+rad*(1-uc));
/* vertex 1 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex1);
cg = render_darken_color(cg, average_light_vertex1);
cb = render_darken_color(cb, average_light_vertex1);
ARR_ADD(x+rad,y+rad,z+rad);
} else {
/* Quad 2 normal */
/* vertex 1 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex1);
cg = render_darken_color(cg, average_light_vertex1);
cb = render_darken_color(cb, average_light_vertex1);
ARR_ADD(x+rad,y+rad,z+rad);
/* vertex 2 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex2);
cg = render_darken_color(cg, average_light_vertex2);
cb = render_darken_color(cb, average_light_vertex2);
ARR_ADD(x+rad*(1-va),y+rad*(1-vb),z+rad*(1-vc));
/* vertex 3 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex3);
cg = render_darken_color(cg, average_light_vertex3);
cb = render_darken_color(cb, average_light_vertex3);
ARR_ADD(x+rad*(1-ua-va),y+rad*(1-ub-vb),z+rad*(1-uc-vc));
/* vertex 4 */
cr = r*s2; cg = g*s2, cb = b*s2;
cr = render_darken_color(cr, average_light_vertex4);
cg = render_darken_color(cg, average_light_vertex4);
cb = render_darken_color(cb, average_light_vertex4);
ARR_ADD(x+rad*(1-ua),y+rad*(1-ub),z+rad*(1-uc));
}
}
#undef ARR_ADD
}
}
void render_vxl_cube(map_t *map, map_chunk_t *chunk, int x, int y, int z, uint8_t *color)
{
render_gl_cube_map(map, chunk, x, y, z, color[2]/255.0f, color[1]/255.0f, color[0]/255.0f, 1);
}
void render_pmf_cube(model_bone_t *bone, float x, float y, float z, int r, int g, int b, float rad)
{
float hrad = rad/2.0f;
render_gl_cube_pmf(bone, x-hrad, y-hrad, z-hrad, r/255.0f, g/255.0f, b/255.0f, rad);
}
void render_vxl_redraw(camera_t *camera, map_t *map)
{
if(map == NULL)
return;
int x,y,z;
int cx,cy,cz;
cx = camera->mpx;
cy = camera->mpy;
cz = camera->mpz;
render_shift_visible_chunks(map, cx/gl_chunk_size, cz/gl_chunk_size);
render_map_tesselate_visible_chunks(map, cx/gl_chunk_size, cz/gl_chunk_size);
}
void render_pillar(map_t *map, map_chunk_t *chunk, int x, int z)
{
int y, i;
if(map == NULL || chunk == NULL)
return;
uint8_t *data = map->pillars[(z&(map->zlen-1))*(map->xlen)+(x&(map->xlen-1))];
data += 4;
int lastct = 0;
for(;;)
{
for(y = data[1]; y <= data[2]; y++)
render_vxl_cube(map, chunk, x, y, z, &data[4*(y-data[1]+1)]);
lastct = -(data[2]-data[1]+1);
if(lastct < 0)
lastct = 0;
lastct += data[0]-1;
if(data[0] == 0)
break;
data += 4*(int)data[0];
for(y = data[3]-lastct; y < data[3]; y++)
render_vxl_cube(map, chunk, x, y, z, &data[4*(y-data[3])]);
}
}
void render_cubemap(uint32_t *pixels, int width, int height, int pitch, camera_t *camera, map_t *map)
{
int x,y,z;
float cx,cy,cz;
float fog[4] = {
((fog_color>>16)&255)/255.0,((fog_color>>8)&255)/255.0,((fog_color)&255)/255.0,1
};
float cfx,cfy,cfz;
cfx = camera->mzx;
cfy = camera->mzy;
cfz = camera->mzz;
float cfd2 = cfx*cfx+cfy*cfy+cfz*cfz;
cfd2 = 1.0f/cfd2;
glClearColor(fog[0], fog[1], fog[2], 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
float cdist = fog_distance/sqrtf(2.0f*cfd2);
glFogf(GL_FOG_START, cdist/2.0f);
glFogf(GL_FOG_END, cdist);
glFogfv(GL_FOG_COLOR, fog);
cx = camera->mpx;
cy = camera->mpy;
cz = camera->mpz;
GLfloat mtx_mv[16] = {
camera->mxx, camera->myx, camera->mzx, 0,
camera->mxy, camera->myy, camera->mzy, 0,
camera->mxz, camera->myz, camera->mzz, 0,
0,0,0,1
};
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(mtx_mv);
glTranslatef(-cx,-cy,-cz);
if(map == NULL)
return;
render_map_visible_chunks_draw(map, cfx, cfy, cfz, cx, cy, cz);
}
void render_pmf_bone(uint32_t *pixels, int width, int height, int pitch, camera_t *cam_base,
model_bone_t *bone, int islocal,
float px, float py, float pz, float ry, float rx, float ry2, float scale)
{
int i;
glEnable(GL_DEPTH_TEST);
glPushMatrix();
if(islocal)
glLoadIdentity();
glTranslatef(px, py, pz);
glScalef(scale,scale,scale);
glRotatef(ry2*180.0f/M_PI, 0.0f, 1.0f, 0.0f);
glRotatef(rx*180.0f/M_PI, 1.0f, 0.0f, 0.0f);
glRotatef(ry*180.0f/M_PI, 0.0f, 1.0f, 0.0f);
if(bone->vbo_dirty)
{
bone->vbo_arr_len = 0;
for(i = 0; i < bone->ptlen; i++)
{
float ox, oy, oz;
const float oamp = 0.0004;
const float oper = 0.031;
ox = oamp*sin(i*oper*M_PI*2.0);
oy = oamp*sin(i*oper*M_PI*2.0 + M_PI*2.0/3.0);
oz = oamp*sin(i*oper*M_PI*2.0 - M_PI*2.0/3.0);
model_point_t *pt = &(bone->pts[i]);
render_pmf_cube(bone, pt->x/256.0f+ox, pt->y/256.0f+oy, pt->z/256.0f+oz, pt->r, pt->g, pt->b, pt->radius*2.0f/256.0f + oamp);
}
bone->vbo_dirty = 0;
if(bone->vbo == 0 && GL_ARB_vertex_buffer_object && gl_use_vbo)
glGenBuffers(1, &(bone->vbo));
if(bone->vbo != 0)
{
glBindBuffer(GL_ARRAY_BUFFER, bone->vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*6*bone->vbo_arr_len, bone->vbo_arr, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}
if(bone->vbo == 0)
{
glVertexPointer(3, GL_FLOAT, sizeof(float)*6, bone->vbo_arr);
glColorPointer(3, GL_FLOAT, sizeof(float)*6, bone->vbo_arr+3);
} else {
glBindBuffer(GL_ARRAY_BUFFER, bone->vbo);
glVertexPointer(3, GL_FLOAT, sizeof(float)*6, (void *)(0));
glColorPointer(3, GL_FLOAT, sizeof(float)*6, (void *)(0 + sizeof(float)*3));
}
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_QUADS, 0, bone->vbo_arr_len);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
if(bone->vbo != 0)
glBindBuffer(GL_ARRAY_BUFFER, 0);
glPopMatrix();
}
int render_init(int width, int height)
{
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(mtx_baseproj);
if(width > height)
glScalef(1.0f,((float)width)/((float)height),1.0f);
else
glScalef(((float)height)/((float)width),1.0f,1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// probably something.
return 0;
}
void render_deinit(void)
{
// probably nothing.
}
Reference in New Issue View Git Blame Copy Permalink