qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-15 01:11:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/glsl/glsl_bsp.c
Bill Currie db7f8a461e [ecs] Move ECS core into its own library 
While the libraries are probably getting a little out of hand, the
separation into its own directory is probably a good thing as an ECS
should not be tied to scenes. This should make the ECS more generally
useful.
2022-10-26 17:24:03 +09:00

1486 lines
40 KiB
C
Raw Blame History

/*
glsl_bsp.c
GLSL bsps
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/1/7
This program 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 2
of the License, or (at your option) any later version.
This program 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 this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
#include "qfalloca.h"
#include "QF/cvar.h"
#include "QF/dstring.h"
#include "QF/image.h"
#include "QF/render.h"
#include "QF/sys.h"
#include "QF/va.h"
#include "QF/scene/entity.h"
#include "QF/GLSL/defines.h"
#include "QF/GLSL/funcs.h"
#include "QF/GLSL/qf_bsp.h"
#include "QF/GLSL/qf_lightmap.h"
#include "QF/GLSL/qf_textures.h"
#include "QF/GLSL/qf_vid.h"
#include "r_internal.h"
typedef struct {
GLushort count;
GLushort indices[1];
} glslpoly_t;
#define ALLOC_CHUNK 64
static instsurf_t *waterchain = NULL;
static instsurf_t **waterchain_tail = &waterchain;
static instsurf_t *sky_chain;
static instsurf_t **sky_chain_tail = &sky_chain;
static glsltex_t **r_texture_chains;
static int r_num_texture_chains;
static int max_texture_chains;
// for world and non-instance models
static instsurf_t *static_instsurfs;
static instsurf_t **static_instsurfs_tail = &static_instsurfs;
static instsurf_t *free_static_instsurfs;
// for instance models
static elechain_t *elechains;
static elechain_t **elechains_tail = &elechains;
static elechain_t *free_elechains;
static elements_t *elementss;
static elements_t **elementss_tail = &elementss;
static elements_t *free_elementss;
static instsurf_t *instsurfs;
static instsurf_t **instsurfs_tail = &instsurfs;
static instsurf_t *free_instsurfs;
static GLuint bsp_vbo;
static mat4f_t bsp_vp;
static GLuint skybox_tex;
static qboolean skybox_loaded;
static quat_t sky_rotation[2];
static quat_t sky_velocity;
static quat_t sky_fix;
static double sky_time;
static quat_t default_color = { 1, 1, 1, 1 };
static quat_t last_color;
static glsltex_t glsl_notexture = { };
static const char *bsp_vert_effects[] =
{
"QuakeForge.Vertex.bsp",
0
};
static const char *bsp_lit_effects[] =
{
"QuakeForge.Fragment.fog",
"QuakeForge.env.warp.nop",
"QuakeForge.Fragment.colormap",
"QuakeForge.Fragment.bsp.lit",
0
};
static const char *bsp_turb_effects[] =
{
"QuakeForge.Math.const",
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.palette",
"QuakeForge.env.warp.turb",
"QuakeForge.Fragment.bsp.unlit",
0
};
static const char *bsp_sky_cube_effects[] =
{
"QuakeForge.Fragment.fog",
"QuakeForge.env.sky.cube",
"QuakeForge.Fragment.bsp.sky",
0
};
static const char *bsp_sky_id_effects[] =
{
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.palette",
"QuakeForge.env.sky.id",
"QuakeForge.Fragment.bsp.sky",
0
};
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t tlst;
shaderparam_t vertex;
shaderparam_t colormap;
shaderparam_t texture;
shaderparam_t lightmap;
shaderparam_t color;
shaderparam_t fog;
} quake_bsp = {
0,
{"mvp_mat", 1},
{"tlst", 0},
{"vertex", 0},
{"colormap", 1},
{"texture", 1},
{"lightmap", 1},
{"vcolor", 0},
{"fog", 1},
};
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t tlst;
shaderparam_t vertex;
shaderparam_t palette;
shaderparam_t texture;
shaderparam_t time;
shaderparam_t color;
shaderparam_t fog;
} quake_turb = {
0,
{"mvp_mat", 1},
{"tlst", 0},
{"vertex", 0},
{"palette", 1},
{"texture", 1},
{"time", 1},
{"vcolor", 0},
{"fog", 1},
};
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t sky_matrix;
shaderparam_t vertex;
shaderparam_t palette;
shaderparam_t solid;
shaderparam_t trans;
shaderparam_t time;
shaderparam_t fog;
} quake_skyid = {
0,
{"mvp_mat", 1},
{"sky_mat", 1},
{"vertex", 0},
{"palette", 1},
{"solid", 1},
{"trans", 1},
{"time", 1},
{"fog", 1},
};
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t sky_matrix;
shaderparam_t vertex;
shaderparam_t sky;
shaderparam_t fog;
} quake_skybox = {
0,
{"mvp_mat", 1},
{"sky_mat", 1},
{"vertex", 0},
{"sky", 1},
{"fog", 1},
};
static struct {
shaderparam_t *mvp_matrix;
shaderparam_t *sky_matrix;
shaderparam_t *vertex;
shaderparam_t *fog;
} sky_params;
typedef struct glslbspctx_s {
mod_brush_t *brush;
animation_t *animation;
vec4f_t *transform;
float *color;
} glslbspctx_t;
#define CHAIN_SURF_F2B(surf,chain) \
({ \
instsurf_t *inst = (surf)->instsurf; \
if (__builtin_expect(!inst, 1)) \
inst = get_instsurf (); \
inst->surface = (surf); \
*(chain##_tail) = inst; \
(chain##_tail) = &inst->tex_chain; \
*(chain##_tail) = 0; \
inst; \
})
#define CHAIN_SURF_B2F(surf,chain) \
({ \
instsurf_t *inst = (surf)->instsurf; \
if (__builtin_expect(!inst, 1)) \
inst = get_instsurf (); \
inst->surface = (surf); \
inst->tex_chain = (chain); \
(chain) = inst; \
inst; \
})
#define GET_RELEASE(type,name) \
static inline type * \
get_##name (void) \
{ \
type *ele; \
if (!free_##name##s) { \
int i; \
free_##name##s = calloc (ALLOC_CHUNK, sizeof (type)); \
for (i = 0; i < ALLOC_CHUNK - 1; i++) \
free_##name##s[i]._next = &free_##name##s[i + 1]; \
} \
ele = free_##name##s; \
free_##name##s = ele->_next; \
ele->_next = 0; \
*name##s_tail = ele; \
name##s_tail = &ele->_next; \
return ele; \
} \
static inline void \
release_##name##s (void) \
{ \
if (name##s) { \
*name##s_tail = free_##name##s; \
free_##name##s = name##s; \
name##s = 0; \
name##s_tail = &name##s; \
} \
}
GET_RELEASE (elechain_t, elechain)
GET_RELEASE (elements_t, elements)
GET_RELEASE (instsurf_t, static_instsurf)
GET_RELEASE (instsurf_t, instsurf)
static void
glsl_R_AddTexture (texture_t *tx)
{
int i;
if (r_num_texture_chains == max_texture_chains) {
max_texture_chains += 64;
r_texture_chains = realloc (r_texture_chains,
max_texture_chains * sizeof (glsltex_t *));
for (i = r_num_texture_chains; i < max_texture_chains; i++)
r_texture_chains[i] = 0;
}
glsltex_t *tex = tx->render;
r_texture_chains[r_num_texture_chains++] = tex;
tex->tex_chain = 0;
tex->tex_chain_tail = &tex->tex_chain;
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
static void
glsl_R_InitSurfaceChains (mod_brush_t *brush)
{
release_static_instsurfs ();
release_instsurfs ();
for (unsigned i = 0; i < brush->nummodelsurfaces; i++) {
brush->surfaces[i].instsurf = get_static_instsurf ();
brush->surfaces[i].instsurf->surface = &brush->surfaces[i];
}
}
static inline void
clear_tex_chain (glsltex_t *tex)
{
tex->tex_chain = 0;
tex->tex_chain_tail = &tex->tex_chain;
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
static void
clear_texture_chains (void)
{
int i;
for (i = 0; i < r_num_texture_chains; i++) {
if (!r_texture_chains[i])
continue;
clear_tex_chain (r_texture_chains[i]);
}
clear_tex_chain (r_notexture_mip->render);
release_elechains ();
release_elementss ();
release_instsurfs ();
}
void
glsl_R_ClearElements (void)
{
release_elechains ();
release_elementss ();
}
static void
update_lightmap (glslbspctx_t *bctx, msurface_t *surf)
{
int maps;
for (maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++)
if (d_lightstylevalue[surf->styles[maps]] != surf->cached_light[maps])
goto dynamic;
if ((surf->dlightframe == r_framecount) || surf->cached_dlight) {
dynamic:
if (r_dynamic)
glsl_R_BuildLightMap (bctx->transform, bctx->brush, surf);
}
}
static inline void
chain_surface (glslbspctx_t *bctx, msurface_t *surf)
{
instsurf_t *is;
if (surf->flags & SURF_DRAWSKY) {
is = CHAIN_SURF_F2B (surf, sky_chain);
} else if ((surf->flags & SURF_DRAWTURB)
|| (bctx->color && bctx->color[3] < 1.0)) {
is = CHAIN_SURF_B2F (surf, waterchain);
} else {
texture_t *tx;
glsltex_t *tex;
if (!surf->texinfo->texture->anim_total)
tx = surf->texinfo->texture;
else
tx = R_TextureAnimation (bctx->animation->frame, surf);
tex = tx->render;
is = CHAIN_SURF_F2B (surf, tex->tex_chain);
update_lightmap (bctx, surf);
}
is->transform = bctx->transform;
is->color = bctx->color;
}
static void
register_textures (mod_brush_t *brush)
{
texture_t *tex;
for (unsigned i = 0; i < brush->numtextures; i++) {
tex = brush->textures[i];
if (!tex)
continue;
glsl_R_AddTexture (tex);
}
}
static void
glsl_R_ClearTextures (void)
{
r_num_texture_chains = 0;
}
void
glsl_R_RegisterTextures (model_t **models, int num_models)
{
int i;
model_t *m;
mod_brush_t *brush;
glsl_R_ClearTextures ();
glsl_R_InitSurfaceChains (&r_refdef.worldmodel->brush);
glsl_R_AddTexture (r_notexture_mip);
register_textures (&r_refdef.worldmodel->brush);
for (i = 0; i < num_models; i++) {
m = models[i];
if (!m)
continue;
// sub-models are done as part of the main model
if (*m->path == '*')
continue;
// world has already been done, not interested in non-brush models
if (m == r_refdef.worldmodel || m->type != mod_brush)
continue;
brush = &m->brush;
brush->numsubmodels = 1; // no support for submodels in non-world model
register_textures (brush);
}
}
static elechain_t *
add_elechain (glsltex_t *tex, int model_index)
{
elechain_t *ec;
ec = get_elechain ();
ec->elements = get_elements ();
ec->model_index = model_index;
ec->transform = 0;
ec->color = 0;
*tex->elechain_tail = ec;
tex->elechain_tail = &ec->next;
return ec;
}
static void
build_surf_displist (model_t **models, msurface_t *surf, int base,
dstring_t *vert_list)
{
mod_brush_t *brush;
if (surf->model_index < 0) {
brush = &models[-surf->model_index - 1]->brush;
} else {
brush = &r_refdef.worldmodel->brush;
}
mvertex_t *vertices = brush->vertexes;
medge_t *edges = brush->edges;
int *surfedges = brush->surfedges;
// create triangle soup for the polygon (this was written targeting
// GLES 2, which didn't have primitive restart)
int numverts = surf->numedges;
int numtris = numverts - 2;
int numindices = numtris * 3;
glslpoly_t *poly = malloc (field_offset (glslpoly_t, indices[numindices]));
poly->count = numindices;
for (int i = 0, ind = 0; i < numtris; i++) {
// pretend we can use a triangle fan
poly->indices[ind++] = base;
poly->indices[ind++] = base + i + 1;
poly->indices[ind++] = base + i + 2;
}
surf->polys = (glpoly_t *) poly;
bspvert_t *verts = alloca (numverts * sizeof (bspvert_t));
mtexinfo_t *texinfo = surf->texinfo;
for (int i = 0; i < numverts; i++) {
vec_t *vec;
int index = surfedges[surf->firstedge + i];
if (index > 0) {
// forward edge
vec = vertices[edges[index].v[0]].position;
} else {
// reverse edge
vec = vertices[edges[-index].v[1]].position;
}
VectorCopy (vec, verts[i].vertex);
verts[i].vertex[3] = 1; // homogeneous coord
vec2f_t st = {
DotProduct (vec, texinfo->vecs[0]) + texinfo->vecs[0][3],
DotProduct (vec, texinfo->vecs[1]) + texinfo->vecs[1][3],
};
verts[i].tlst[0] = st[0] / texinfo->texture->width;
verts[i].tlst[1] = st[1] / texinfo->texture->height;
if (surf->lightpic) {
//lightmap texture coordinates
//every lit surface has its own lighmap at a 1/16 resolution
//(ie, 16 albedo pixels for every lightmap pixel)
const vrect_t *rect = surf->lightpic->rect;
vec2f_t lmorg = (vec2f_t) { VEC2_EXP (&rect->x) } * 16 + 8;
vec2f_t texorg = { VEC2_EXP (surf->texturemins) };
st = ((st - texorg + lmorg) / 16) * surf->lightpic->size;
verts[i].tlst[2] = st[0];
verts[i].tlst[3] = st[1];
} else {
// no lightmap for this surface (probably sky or water), so
// make the lightmap texture polygone degenerate
verts[i].tlst[2] = 0;
verts[i].tlst[3] = 0;
}
}
dstring_append (vert_list, (char *) verts, numverts * sizeof (bspvert_t));
}
void
glsl_R_BuildDisplayLists (model_t **models, int num_models)
{
int vertex_index_base;
model_t *m;
dmodel_t *dm;
msurface_t *surf;
dstring_t *vertices;
mod_brush_t *brush;
QuatSet (0, 0, sqrt(0.5), sqrt(0.5), sky_fix); // proper skies
QuatSet (0, 0, 0, 1, sky_rotation[0]);
QuatCopy (sky_rotation[0], sky_rotation[1]);
QuatSet (0, 0, 0, 0, sky_velocity);
QuatExp (sky_velocity, sky_velocity);
sky_time = vr_data.realtime;
// now run through all surfaces, chaining them to their textures, thus
// effectively sorting the surfaces by texture (without worrying about
// surface order on the same texture chain).
for (int i = 0; i < num_models; i++) {
m = models[i];
if (!m)
continue;
// sub-models are done as part of the main model
if (*m->path == '*' || m->type != mod_brush)
continue;
brush = &m->brush;
// non-bsp models don't have surfaces.
dm = brush->submodels;
for (uint32_t j = 0; j < brush->numsurfaces; j++) {
glsltex_t *tex;
if (j == dm->firstface + dm->numfaces) {
dm++;
if (dm == brush->submodels + brush->numsubmodels) {
// limit the surfaces
// probably never hit
Sys_Printf ("R_BuildDisplayLists: too many surfaces\n");
brush->numsurfaces = j;
break;
}
}
surf = brush->surfaces + j;
surf->model_index = dm - brush->submodels;
if (!surf->model_index && m != r_refdef.worldmodel)
surf->model_index = -1 - i; // instanced model
tex = surf->texinfo->texture->render;
CHAIN_SURF_F2B (surf, tex->tex_chain);
}
}
// All vertices from all brush models go into one giant vbo.
vertices = dstring_new ();
vertex_index_base = 0;
// All usable surfaces have been chained to the (base) texture they use.
// Run through the textures, using their chains to build display maps.
// For animated textures, if a surface is on one texture of the group, it
// will be on all.
for (int i = 0; i < r_num_texture_chains; i++) {
glsltex_t *tex;
instsurf_t *is;
elechain_t *ec = 0;
elements_t *el = 0;
tex = r_texture_chains[i];
for (is = tex->tex_chain; is; is = is->tex_chain) {
msurface_t *surf = is->surface;
if (!tex->elechain) {
ec = add_elechain (tex, surf->model_index);
el = ec->elements;
el->base = (byte *) (intptr_t) vertices->size;
vertex_index_base = 0;
}
if (surf->model_index != ec->model_index) { // next sub-model
ec = add_elechain (tex, surf->model_index);
el = ec->elements;
el->base = (byte *) (intptr_t) vertices->size;
vertex_index_base = 0;
}
if (vertex_index_base + surf->numedges > 65535) {
// elements index overflow
el->next = get_elements ();
el = el->next;
el->base = (byte *) (intptr_t) vertices->size;
vertex_index_base = 0;
}
// we don't use it now, but pre-initializing the list won't hurt
if (!el->list)
el->list = dstring_new ();
dstring_clear (el->list);
surf->base = el->base;
build_surf_displist (models, surf, vertex_index_base, vertices);
vertex_index_base += surf->numedges;
}
}
clear_texture_chains ();
Sys_MaskPrintf (SYS_glsl, "R_BuildDisplayLists: %ld verts total\n",
(long) (vertices->size / sizeof (bspvert_t)));
if (!bsp_vbo)
qfeglGenBuffers (1, &bsp_vbo);
qfeglBindBuffer (GL_ARRAY_BUFFER, bsp_vbo);
qfeglBufferData (GL_ARRAY_BUFFER, vertices->size, vertices->str,
GL_STATIC_DRAW);
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
dstring_delete (vertices);
}
static void
R_DrawBrushModel (entity_t e)
{
float dot, radius;
unsigned k;
renderer_t *renderer = Ent_GetComponent (e.id, scene_renderer, e.reg);
model_t *model = renderer->model;
mod_brush_t *brush = &model->brush;
plane_t *plane;
msurface_t *surf;
qboolean rotated;
vec3_t mins, maxs;
vec4f_t org;
glslbspctx_t bctx = {
brush,
Ent_GetComponent (e.id, scene_animation, e.reg),
renderer->full_transform,
renderer->colormod,
};
mat4f_t mat;
transform_t transform = Entity_Transform (e);
Transform_GetWorldMatrix (transform, mat);
memcpy (renderer->full_transform, mat, sizeof (mat));//FIXME
if (mat[0][0] != 1 || mat[1][1] != 1 || mat[2][2] != 1) {
rotated = true;
radius = model->radius;
if (R_CullSphere (r_refdef.frustum, (vec_t*)&mat[3], radius)) { // FIXME
return;
}
} else {
rotated = false;
VectorAdd (mat[3], model->mins, mins);
VectorAdd (mat[3], model->maxs, maxs);
if (R_CullBox (r_refdef.frustum, mins, maxs))
return;
}
org = r_refdef.frame.position - mat[3];
if (rotated) {
vec4f_t temp = org;
org[0] = dotf (temp, mat[0])[0];
org[1] = dotf (temp, mat[1])[0];
org[2] = dotf (temp, mat[2])[0];
}
// calculate dynamic lighting for bmodel if it's not an instanced model
if (brush->firstmodelsurface != 0 && r_dlight_lightmap) {
for (k = 0; k < r_maxdlights; k++) {
if ((r_dlights[k].die < vr_data.realtime)
|| (!r_dlights[k].radius))
continue;
vec4f_t lightorigin;
VectorSubtract (r_dlights[k].origin, mat[3], lightorigin);
lightorigin[3] = 1;
R_RecursiveMarkLights (brush, lightorigin, &r_dlights[k], k,
brush->hulls[0].firstclipnode);
}
}
surf = &brush->surfaces[brush->firstmodelsurface];
for (unsigned i = 0; i < brush->nummodelsurfaces; i++, surf++) {
// find the node side on which we are
plane = surf->plane;
dot = PlaneDiff (org, plane);
// enqueue the polygon
if (((surf->flags & SURF_PLANEBACK) && (dot < -BACKFACE_EPSILON))
|| (!(surf->flags & SURF_PLANEBACK) && (dot > BACKFACE_EPSILON))) {
chain_surface (&bctx, surf);
}
}
}
static inline void
visit_leaf (mleaf_t *leaf)
{
// deal with model fragments in this leaf
if (leaf->efrags)
R_StoreEfrags (leaf->efrags);
}
// 1 = back side, 0 = front side
static inline int
get_side (mnode_t *node)
{
// find the node side on which we are
vec4f_t org = r_refdef.frame.position;
return dotf (org, node->plane)[0] < 0;
}
static inline void
visit_node (glslbspctx_t *bctx, mnode_t *node, int side)
{
int c;
msurface_t *surf;
// sneaky hack for side = side ? SURF_PLANEBACK : 0;
// seems to be microscopically faster even on modern hardware
side = (-side) & SURF_PLANEBACK;
// chain any visible surfaces on the node that face the camera.
// not all nodes have any surfaces to draw (purely a split plane)
if ((c = node->numsurfaces)) {
int surf_id = node->firstsurface;
surf = bctx->brush->surfaces + surf_id;
for (; c; c--, surf++, surf_id++) {
if (r_face_visframes[surf_id] != r_visframecount)
continue;
// side is either 0 or SURF_PLANEBACK
// if side and the surface facing differ, then the camera is
// on backside of the surface
if (side ^ (surf->flags & SURF_PLANEBACK))
continue; // wrong side
chain_surface (bctx, surf);
}
}
}
static inline int
test_node (glslbspctx_t *bctx, int node_id)
{
if (node_id < 0)
return 0;
if (r_node_visframes[node_id] != r_visframecount)
return 0;
mnode_t *node = bctx->brush->nodes + node_id;
if (R_CullBox (r_refdef.frustum, node->minmaxs, node->minmaxs + 3))
return 0;
return 1;
}
static void
R_VisitWorldNodes (glslbspctx_t *bctx)
{
typedef struct {
int node_id;
int side;
} rstack_t;
mod_brush_t *brush = bctx->brush;
rstack_t *node_ptr;
rstack_t *node_stack;
int node_id;
int front;
int side;
node_id = 0;
// +2 for paranoia
node_stack = alloca ((brush->depth + 2) * sizeof (rstack_t));
node_ptr = node_stack;
while (1) {
while (test_node (bctx, node_id)) {
mnode_t *node = bctx->brush->nodes + node_id;
side = get_side (node);
front = node->children[side];
if (test_node (bctx, front)) {
node_ptr->node_id = node_id;
node_ptr->side = side;
node_ptr++;
node_id = front;
continue;
}
if (front < 0) {
mleaf_t *leaf = bctx->brush->leafs + ~front;
if (leaf->contents != CONTENTS_SOLID) {
visit_leaf (leaf);
}
}
visit_node (bctx, node, side);
node_id = node->children[side ^ 1];
}
if (node_id < 0) {
mleaf_t *leaf = bctx->brush->leafs + ~node_id;
if (leaf->contents != CONTENTS_SOLID) {
visit_leaf (leaf);
}
}
if (node_ptr != node_stack) {
node_ptr--;
node_id = node_ptr->node_id;
side = node_ptr->side;
mnode_t *node = bctx->brush->nodes + node_id;
visit_node (bctx, node, side);
node_id = node->children[side ^ 1];
continue;
}
break;
}
}
static void
draw_elechain (elechain_t *ec, int matloc, int vertloc, int tlstloc,
int colloc)
{
mat4f_t mat;
elements_t *el;
int count;
float *color;
if (colloc >= 0) {
color = ec->color;
if (!color)
color = default_color;
if (!QuatCompare (color, last_color)) {
QuatCopy (color, last_color);
qfeglVertexAttrib4fv (quake_bsp.color.location, color);
}
}
if (ec->transform) {
mmulf (mat, bsp_vp, ec->transform);
qfeglUniformMatrix4fv (matloc, 1, false, (vec_t*)&mat[0]);//FIXME
} else {
qfeglUniformMatrix4fv (matloc, 1, false, (vec_t*)&bsp_vp[0]);//FIXME
}
for (el = ec->elements; el; el = el->next) {
if (!el->list->size)
continue;
count = el->list->size / sizeof (GLushort);
qfeglVertexAttribPointer (vertloc, 4, GL_FLOAT,
0, sizeof (bspvert_t),
el->base + field_offset (bspvert_t, vertex));
if (tlstloc >= 0)
qfeglVertexAttribPointer (tlstloc, 4, GL_FLOAT,
0, sizeof (bspvert_t),
el->base + field_offset (bspvert_t,tlst));
qfeglDrawElements (GL_TRIANGLES, count,
GL_UNSIGNED_SHORT, el->list->str);
dstring_clear (el->list);
}
}
static void
bsp_begin (void)
{
quat_t fog;
default_color[3] = 1;
QuatCopy (default_color, last_color);
qfeglVertexAttrib4fv (quake_bsp.color.location, default_color);
mmulf (bsp_vp, glsl_projection, glsl_view);
qfeglUseProgram (quake_bsp.program);
qfeglEnableVertexAttribArray (quake_bsp.vertex.location);
qfeglEnableVertexAttribArray (quake_bsp.tlst.location);
qfeglDisableVertexAttribArray (quake_bsp.color.location);
qfeglVertexAttrib4fv (quake_bsp.color.location, default_color);
Fog_GetColor (fog);
fog[3] = Fog_GetDensity () / 64.0;
qfeglUniform4fv (quake_bsp.fog.location, 1, fog);
qfeglUniform1i (quake_bsp.colormap.location, 2);
qfeglActiveTexture (GL_TEXTURE0 + 2);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, glsl_colormap);
qfeglUniform1i (quake_bsp.lightmap.location, 1);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, glsl_R_LightmapTexture ());
qfeglUniform1i (quake_bsp.texture.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindBuffer (GL_ARRAY_BUFFER, bsp_vbo);
}
static void
bsp_end (void)
{
qfeglDisableVertexAttribArray (quake_bsp.vertex.location);
qfeglDisableVertexAttribArray (quake_bsp.tlst.location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglDisable (GL_TEXTURE_2D);
qfeglActiveTexture (GL_TEXTURE0 + 2);
qfeglDisable (GL_TEXTURE_2D);
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
}
static void
turb_begin (void)
{
quat_t fog;
default_color[3] = bound (0, r_wateralpha, 1);
QuatCopy (default_color, last_color);
qfeglVertexAttrib4fv (quake_bsp.color.location, default_color);
mmulf (bsp_vp, glsl_projection, glsl_view);
qfeglUseProgram (quake_turb.program);
qfeglEnableVertexAttribArray (quake_turb.vertex.location);
qfeglEnableVertexAttribArray (quake_turb.tlst.location);
qfeglDisableVertexAttribArray (quake_turb.color.location);
qfeglVertexAttrib4fv (quake_turb.color.location, default_color);
Fog_GetColor (fog);
fog[3] = Fog_GetDensity () / 64.0;
qfeglUniform4fv (quake_turb.fog.location, 1, fog);
qfeglUniform1i (quake_turb.palette.location, 1);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, glsl_palette);
qfeglUniform1f (quake_turb.time.location, vr_data.realtime);
qfeglUniform1i (quake_turb.texture.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindBuffer (GL_ARRAY_BUFFER, bsp_vbo);
}
static void
turb_end (void)
{
qfeglDisableVertexAttribArray (quake_turb.vertex.location);
qfeglDisableVertexAttribArray (quake_turb.tlst.location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglDisable (GL_TEXTURE_2D);
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
}
static void
spin (mat4_t mat)
{
quat_t q;
mat4_t m;
float blend;
while (vr_data.realtime - sky_time > 1) {
QuatCopy (sky_rotation[1], sky_rotation[0]);
QuatMult (sky_velocity, sky_rotation[0], sky_rotation[1]);
sky_time += 1;
}
blend = bound (0, (vr_data.realtime - sky_time), 1);
QuatBlend (sky_rotation[0], sky_rotation[1], blend, q);
QuatMult (sky_fix, q, q);
Mat4Identity (mat);
VectorNegate (r_refdef.frame.position, mat + 12);
QuatToMatrix (q, m, 1, 1);
Mat4Mult (m, mat, mat);
}
static void
sky_begin (void)
{
mat4_t mat;
quat_t fog;
default_color[3] = 1;
QuatCopy (default_color, last_color);
qfeglVertexAttrib4fv (quake_bsp.color.location, default_color);
mmulf (bsp_vp, glsl_projection, glsl_view);
if (skybox_loaded) {
sky_params.mvp_matrix = &quake_skybox.mvp_matrix;
sky_params.vertex = &quake_skybox.vertex;
sky_params.sky_matrix = &quake_skybox.sky_matrix;
sky_params.fog = &quake_skybox.fog;
qfeglUseProgram (quake_skybox.program);
qfeglEnableVertexAttribArray (quake_skybox.vertex.location);
qfeglUniform1i (quake_skybox.sky.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_CUBE_MAP);
qfeglBindTexture (GL_TEXTURE_CUBE_MAP, skybox_tex);
} else {
sky_params.mvp_matrix = &quake_skyid.mvp_matrix;
sky_params.sky_matrix = &quake_skyid.sky_matrix;
sky_params.vertex = &quake_skyid.vertex;
sky_params.fog = &quake_skyid.fog;
qfeglUseProgram (quake_skyid.program);
qfeglEnableVertexAttribArray (quake_skyid.vertex.location);
qfeglUniform1i (quake_skyid.palette.location, 2);
qfeglActiveTexture (GL_TEXTURE0 + 2);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, glsl_palette);
qfeglUniform1f (quake_skyid.time.location, vr_data.realtime);
qfeglUniform1i (quake_skyid.trans.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglUniform1i (quake_skyid.solid.location, 1);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglEnable (GL_TEXTURE_2D);
}
Fog_GetColor (fog);
fog[3] = Fog_GetDensity () / 64.0;
qfeglUniform4fv (sky_params.fog->location, 1, fog);
spin (mat);
qfeglUniformMatrix4fv (sky_params.sky_matrix->location, 1, false, mat);
qfeglBindBuffer (GL_ARRAY_BUFFER, bsp_vbo);
}
static void
sky_end (void)
{
qfeglDisableVertexAttribArray (sky_params.vertex->location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
qfeglDisable (GL_TEXTURE_CUBE_MAP);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglDisable (GL_TEXTURE_2D);
qfeglActiveTexture (GL_TEXTURE0 + 2);
qfeglDisable (GL_TEXTURE_2D);
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
}
static inline void
add_surf_elements (glsltex_t *tex, instsurf_t *is,
elechain_t **ec, elements_t **el)
{
msurface_t *surf = is->surface;
glslpoly_t *poly = (glslpoly_t *) surf->polys;
if (!tex->elechain) {
(*ec) = add_elechain (tex, surf->model_index);
(*ec)->transform = is->transform;
(*ec)->color = is->color;
(*el) = (*ec)->elements;
(*el)->base = surf->base;
if (!(*el)->list)
(*el)->list = dstring_new ();
dstring_clear ((*el)->list);
}
if (is->transform != (*ec)->transform || is->color != (*ec)->color) {
(*ec) = add_elechain (tex, surf->model_index);
(*ec)->transform = is->transform;
(*ec)->color = is->color;
(*el) = (*ec)->elements;
(*el)->base = surf->base;
if (!(*el)->list)
(*el)->list = dstring_new ();
dstring_clear ((*el)->list);
}
if (surf->base != (*el)->base) {
(*el)->next = get_elements ();
(*el) = (*el)->next;
(*el)->base = surf->base;
if (!(*el)->list)
(*el)->list = dstring_new ();
dstring_clear ((*el)->list);
}
dstring_append ((*el)->list, (char *) poly->indices,
poly->count * sizeof (poly->indices[0]));
}
static void
build_tex_elechain (glsltex_t *tex)
{
instsurf_t *is;
elechain_t *ec = 0;
elements_t *el = 0;
for (is = tex->tex_chain; is; is = is->tex_chain) {
add_surf_elements (tex, is, &ec, &el);
}
}
void
glsl_R_DrawWorld (void)
{
animation_t animation = {};
glslbspctx_t bctx = { };
int i;
clear_texture_chains (); // do this first for water and skys
bctx.brush = &r_refdef.worldmodel->brush;
bctx.animation = &animation;
R_VisitWorldNodes (&bctx);
if (r_drawentities) {
for (size_t i = 0; i < r_ent_queue->ent_queues[mod_brush].size; i++) {
entity_t ent = r_ent_queue->ent_queues[mod_brush].a[i];
R_DrawBrushModel (ent);
}
}
glsl_R_FlushLightmaps ();
bsp_begin ();
qfeglActiveTexture (GL_TEXTURE0 + 0);
for (i = 0; i < r_num_texture_chains; i++) {
glsltex_t *tex;
elechain_t *ec = 0;
tex = r_texture_chains[i];
build_tex_elechain (tex);
if (tex->elechain)
qfeglBindTexture (GL_TEXTURE_2D, tex->gl_texturenum);
for (ec = tex->elechain; ec; ec = ec->next) {
draw_elechain (ec, quake_bsp.mvp_matrix.location,
quake_bsp.vertex.location,
quake_bsp.tlst.location,
quake_bsp.color.location);
}
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
bsp_end ();
}
void
glsl_R_DrawWaterSurfaces (void)
{
instsurf_t *is;
msurface_t *surf;
glsltex_t *tex = 0;
elechain_t *ec = 0;
elements_t *el = 0;
if (!waterchain)
return;
turb_begin ();
for (is = waterchain; is; is = is->tex_chain) {
surf = is->surface;
if (tex != surf->texinfo->texture->render) {
if (tex) {
qfeglBindTexture (GL_TEXTURE_2D, tex->gl_texturenum);
for (ec = tex->elechain; ec; ec = ec->next)
draw_elechain (ec, quake_turb.mvp_matrix.location,
quake_turb.vertex.location,
quake_turb.tlst.location,
quake_turb.color.location);
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
tex = surf->texinfo->texture->render;
}
add_surf_elements (tex, is, &ec, &el);
}
if (tex) {
qfeglBindTexture (GL_TEXTURE_2D, tex->gl_texturenum);
for (ec = tex->elechain; ec; ec = ec->next)
draw_elechain (ec, quake_turb.mvp_matrix.location,
quake_turb.vertex.location,
quake_turb.tlst.location,
quake_turb.color.location);
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
turb_end ();
waterchain = 0;
waterchain_tail = &waterchain;
}
void
glsl_R_DrawSky (void)
{
instsurf_t *is;
msurface_t *surf;
glsltex_t *tex = 0;
elechain_t *ec = 0;
elements_t *el = 0;
if (!sky_chain)
return;
sky_begin ();
for (is = sky_chain; is; is = is->tex_chain) {
surf = is->surface;
if (tex != surf->texinfo->texture->render) {
if (tex) {
if (!skybox_loaded) {
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglBindTexture (GL_TEXTURE_2D, tex->sky_tex[0]);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglBindTexture (GL_TEXTURE_2D, tex->sky_tex[1]);
}
for (ec = tex->elechain; ec; ec = ec->next)
draw_elechain (ec, sky_params.mvp_matrix->location,
sky_params.vertex->location, -1, -1);
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
tex = surf->texinfo->texture->render;
}
add_surf_elements (tex, is, &ec, &el);
}
if (tex) {
if (!skybox_loaded) {
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglBindTexture (GL_TEXTURE_2D, tex->sky_tex[0]);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglBindTexture (GL_TEXTURE_2D, tex->sky_tex[1]);
}
for (ec = tex->elechain; ec; ec = ec->next)
draw_elechain (ec, sky_params.mvp_matrix->location,
sky_params.vertex->location, -1, -1);
tex->elechain = 0;
tex->elechain_tail = &tex->elechain;
}
sky_end ();
sky_chain = 0;
sky_chain_tail = &sky_chain;
}
void
glsl_R_InitBsp (void)
{
shader_t *vert_shader, *frag_shader;
int vert;
int frag;
r_notexture_mip->render = &glsl_notexture;
vert_shader = GLSL_BuildShader (bsp_vert_effects);
frag_shader = GLSL_BuildShader (bsp_lit_effects);
vert = GLSL_CompileShader ("quakebsp.vert", vert_shader,
GL_VERTEX_SHADER);
frag = GLSL_CompileShader ("quakebsp.frag", frag_shader,
GL_FRAGMENT_SHADER);
quake_bsp.program = GLSL_LinkProgram ("quakebsp", vert, frag);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.mvp_matrix);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.tlst);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.vertex);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.colormap);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.texture);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.lightmap);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.color);
GLSL_ResolveShaderParam (quake_bsp.program, &quake_bsp.fog);
GLSL_FreeShader (vert_shader);
GLSL_FreeShader (frag_shader);
frag_shader = GLSL_BuildShader (bsp_turb_effects);
frag = GLSL_CompileShader ("quaketrb.frag", frag_shader,
GL_FRAGMENT_SHADER);
quake_turb.program = GLSL_LinkProgram ("quaketrb", vert, frag);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.mvp_matrix);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.tlst);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.vertex);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.palette);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.texture);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.time);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.color);
GLSL_ResolveShaderParam (quake_turb.program, &quake_turb.fog);
GLSL_FreeShader (frag_shader);
frag_shader = GLSL_BuildShader (bsp_sky_id_effects);
frag = GLSL_CompileShader ("quakeski.frag", frag_shader,
GL_FRAGMENT_SHADER);
quake_skyid.program = GLSL_LinkProgram ("quakeskyid", vert, frag);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.mvp_matrix);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.sky_matrix);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.vertex);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.palette);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.solid);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.trans);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.time);
GLSL_ResolveShaderParam (quake_skyid.program, &quake_skyid.fog);
GLSL_FreeShader (frag_shader);
frag_shader = GLSL_BuildShader (bsp_sky_cube_effects);
frag = GLSL_CompileShader ("quakeskb.frag", frag_shader,
GL_FRAGMENT_SHADER);
quake_skybox.program = GLSL_LinkProgram ("quakeskybox", vert, frag);
GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.mvp_matrix);
GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky_matrix);
GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.vertex);
GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.sky);
GLSL_ResolveShaderParam (quake_skybox.program, &quake_skybox.fog);
GLSL_FreeShader (frag_shader);
}
static inline __attribute__((const)) int
is_pow2 (unsigned x)
{
int count;
for (count = 0; x; x >>= 1)
if (x & 1)
count++;
return count == 1;
}
// NOTE: this expects the destination tex_t to be set up: memory allocated
// and dimentions/format etc already set. the size of the rect to be copied
// is taken from dst. Also, dst->format and src->format must be the same, and
// either 3 or 4, or bad things will happen. Also, no clipping is done, so if
// x < 0 or y < 0 or x + dst->width > src->width
// or y + dst->height > src->height, bad things will happen.
static void
copy_sub_tex (tex_t *src, int x, int y, tex_t *dst)
{
int dstbytes;
int srcbytes;
int i;
srcbytes = src->width * src->format;
dstbytes = dst->width * dst->format;
x *= src->format;
for (i = 0; i < dst->height; i++)
memcpy (dst->data + i * dstbytes, src->data + (i + y) * srcbytes + x,
dstbytes);
}
void
glsl_R_LoadSkys (const char *sky)
{
const char *name;
int i;
tex_t *tex;
// NOTE: quake's world and GL's world are rotated relative to each other
// quake has x right, y in, z up. gl has x right, y up, z out
// quake order: +x -x +z -z +y -y
// gl order: +x -x +y -y +z -z
// fizquake orger: -y +y +z -z +x -x
// to get from quake order to fitzquake order, all that's needed is
// a -90 degree rotation on the (quake) z-axis. This is taken care of in
// the sky_matrix setup code.
// However, from the player's perspective, skymaps have lf and rt
// swapped, but everything makes sense if looking at the cube from outside
// along the positive y axis, with the front of the cube being the nearest
// face. This matches nicely with Blender's default cube in front (num-1)
// view.
static const char *sky_suffix[] = { "ft", "bk", "up", "dn", "rt", "lf"};
static int sky_coords[][2] = {
{2, 0}, // front
{0, 0}, // back
{1, 1}, // up
{0, 1}, // down
{2, 1}, // left
{1, 0}, // right
};
if (!sky || !*sky)
sky = r_skyname;
if (!*sky || !strcasecmp (sky, "none")) {
skybox_loaded = false;
return;
}
if (!skybox_tex)
qfeglGenTextures (1, &skybox_tex);
qfeglBindTexture (GL_TEXTURE_CUBE_MAP, skybox_tex);
//blender envmap
// bk rt ft
// dn up lt
tex = LoadImage (name = va (0, "env/%s_map", sky), 1);
if (tex && tex->format >= 3 && tex->height * 3 == tex->width * 2
&& is_pow2 (tex->height)) {
tex_t *sub;
int size = tex->height / 2;
skybox_loaded = true;
sub = malloc (sizeof (tex_t) + size * size * tex->format);
sub->data = (byte *) (sub + 1);
sub->width = size;
sub->height = size;
sub->format = tex->format;
sub->palette = tex->palette;
for (i = 0; i < 6; i++) {
int x, y;
x = sky_coords[i][0] * size;
y = sky_coords[i][1] * size;
copy_sub_tex (tex, x, y, sub);
qfeglTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
sub->format == 3 ? GL_RGB : GL_RGBA,
sub->width, sub->height, 0,
sub->format == 3 ? GL_RGB : GL_RGBA,
GL_UNSIGNED_BYTE, sub->data);
}
free (sub);
} else {
skybox_loaded = true;
for (i = 0; i < 6; i++) {
tex = LoadImage (name = va (0, "env/%s%s", sky, sky_suffix[i]), 1);
if (!tex || tex->format < 3) { // FIXME pcx support
Sys_MaskPrintf (SYS_glsl, "Couldn't load %s\n", name);
// also look in gfx/env, where Darkplaces looks for skies
tex = LoadImage (name = va (0, "gfx/env/%s%s", sky,
sky_suffix[i]), 1);
if (!tex || tex->format < 3) { // FIXME pcx support
Sys_MaskPrintf (SYS_glsl, "Couldn't load %s\n", name);
skybox_loaded = false;
continue;
}
}
Sys_MaskPrintf (SYS_glsl, "Loaded %s\n", name);
qfeglTexImage2D (GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
tex->format == 3 ? GL_RGB : GL_RGBA,
tex->width, tex->height, 0,
tex->format == 3 ? GL_RGB : GL_RGBA,
GL_UNSIGNED_BYTE, tex->data);
}
}
qfeglTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
qfeglTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
qfeglTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qfeglTexParameteri (GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qfeglGenerateMipmap (GL_TEXTURE_CUBE_MAP);
}
Reference in a new issue View git blame Copy permalink