qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-27 06:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/renderer/glsl/glsl_iqm.c
Bill Currie 9db80259d1 [gl,glsl] Copy fog color rather than return pointer 
The static variable meant that Fog_GetColor was not thread-safe (though
multiple calls in the one thread look to be ok for now). However, this
change takes it one step closer to being more generally usable.

Patch found in an old stash.
2020-12-24 16:43:28 +09:00

304 lines
8.7 KiB
C
Raw Blame History

/*
glsl_iqm.c
GLSL IQM rendering
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/5/11
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
#define NH_DEFINE
#include "namehack.h"
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
#include "QF/cvar.h"
#include "QF/render.h"
#include "QF/skin.h"
#include "QF/sys.h"
#include "QF/GLSL/defines.h"
#include "QF/GLSL/funcs.h"
#include "QF/GLSL/qf_iqm.h"
#include "QF/GLSL/qf_textures.h"
#include "QF/GLSL/qf_vid.h"
#include "r_internal.h"
static const char *iqm_vert_effects[] =
{
"QuakeForge.Math.quaternion",
"QuakeForge.Vertex.iqm",
0
};
static const char *iqm_frag_effects[] =
{
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.iqm",
0
};
typedef struct {
shaderparam_t position;
shaderparam_t color;
} lightpar_t;
#define MAX_IQM_LIGHTS 8
#define MAX_IQM_BONES 80
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t norm_matrix;
shaderparam_t bonemats;
shaderparam_t vcolor;
shaderparam_t vweights;
shaderparam_t vbones;
shaderparam_t texcoord;
shaderparam_t vtangent;
shaderparam_t vnormal;
shaderparam_t vposition;
shaderparam_t ambient;
lightpar_t lights[MAX_IQM_LIGHTS];
shaderparam_t texture;
shaderparam_t normalmap;
shaderparam_t fog;
} iqm_shader = {
0,
{"mvp_mat", 1},
{"norm_mat", 1},
{"bonemats", 1},
{"vcolor", 0},
{"vweights", 0},
{"vbones", 0},
{"texcoord", 0},
{"vtangent", 0},
{"vnormal", 0},
{"vposition", 0},
{"ambient", 1},
{
{{"lights[0].position", 1}, {"lights[0].color", 1}},
{{"lights[1].position", 1}, {"lights[1].color", 1}},
{{"lights[2].position", 1}, {"lights[2].color", 1}},
{{"lights[3].position", 1}, {"lights[3].color", 1}},
{{"lights[4].position", 1}, {"lights[4].color", 1}},
{{"lights[5].position", 1}, {"lights[5].color", 1}},
{{"lights[6].position", 1}, {"lights[6].color", 1}},
{{"lights[7].position", 1}, {"lights[7].color", 1}},
},
{"texture", 1},
{"normalmap", 1},
{"fog", 1},
};
static struct va_attr_s {
shaderparam_t *attr;
GLint size;
GLenum type;
GLboolean normalized;
} vertex_attribs[] = {
{&iqm_shader.vposition, 3, GL_FLOAT, 0},
{&iqm_shader.texcoord, 2, GL_FLOAT, 0},
{&iqm_shader.vnormal, 3, GL_FLOAT, 0},
{&iqm_shader.vtangent, 4, GL_FLOAT, 0},
{&iqm_shader.vbones, 4, GL_UNSIGNED_BYTE, 0},
{&iqm_shader.vweights, 4, GL_UNSIGNED_BYTE, 1},
{&iqm_shader.vcolor, 4, GL_UNSIGNED_BYTE, 1},
};
static mat4_t iqm_vp;
void
glsl_R_InitIQM (void)
{
shader_t *vert_shader, *frag_shader;
int vert;
int frag;
int i;
vert_shader = GLSL_BuildShader (iqm_vert_effects);
frag_shader = GLSL_BuildShader (iqm_frag_effects);
vert = GLSL_CompileShader ("iqm.vert", vert_shader, GL_VERTEX_SHADER);
frag = GLSL_CompileShader ("iqm.frag", frag_shader, GL_FRAGMENT_SHADER);
iqm_shader.program = GLSL_LinkProgram ("iqm", vert, frag);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.mvp_matrix);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.norm_matrix);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.bonemats);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vcolor);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vweights);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vbones);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.texcoord);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vtangent);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vnormal);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.vposition);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.ambient);
for (i = 0; i < MAX_IQM_LIGHTS; i++) {
GLSL_ResolveShaderParam (iqm_shader.program,
&iqm_shader.lights[i].position);
GLSL_ResolveShaderParam (iqm_shader.program,
&iqm_shader.lights[i].color);
}
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.texture);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.normalmap);
GLSL_ResolveShaderParam (iqm_shader.program, &iqm_shader.fog);
GLSL_FreeShader (vert_shader);
GLSL_FreeShader (frag_shader);
}
static void
set_arrays (iqm_t *iqm)
{
int i;
uint32_t j;
struct va_attr_s *attr;
iqmvertexarray *va;
for (i = 0, j = 0; i < iqm->num_arrays; i++) {
va = &iqm->vertexarrays[i];
if (va->type > IQM_COLOR)
Sys_Error ("iqm: unknown array type");
if (j > va->type)
Sys_Error ("iqm: array order bogus");
while (j < va->type)
qfeglDisableVertexAttribArray (vertex_attribs[j++].attr->location);
attr = &vertex_attribs[j++];
qfeglEnableVertexAttribArray (attr->attr->location);
qfeglVertexAttribPointer (attr->attr->location, attr->size,
attr->type, attr->normalized, iqm->stride,
iqm->vertices + va->offset);
//(byte *) 0 + va->offset);
}
while (j <= IQM_COLOR)
qfeglDisableVertexAttribArray (vertex_attribs[j++].attr->location);
}
void
glsl_R_DrawIQM (void)
{
static quat_t color = { 1, 1, 1, 1};
entity_t *ent = currententity;
model_t *model = ent->model;
iqm_t *iqm = (iqm_t *) model->aliashdr;
glsliqm_t *glsl = (glsliqm_t *) iqm->extra_data;
dlight_t *lights[MAX_IQM_LIGHTS];
int i;
vec_t norm_mat[9];
mat4_t mvp_mat;
float blend;
iqmframe_t *frame;
R_LightPoint (ent->origin); //FIXME min_light?
VectorScale (ambientcolor, 1/255.0, ambientcolor);
R_FindNearLights (ent->origin, MAX_IQM_LIGHTS, lights);
// we need only the rotation for normals.
VectorCopy (ent->transform + 0, norm_mat + 0);
VectorCopy (ent->transform + 4, norm_mat + 3);
VectorCopy (ent->transform + 8, norm_mat + 6);
Mat4Mult (iqm_vp, ent->transform, mvp_mat);
blend = R_IQMGetLerpedFrames (ent, iqm);
frame = R_IQMBlendFrames (iqm, ent->pose1, ent->pose2, blend, 0);
qfeglUniform3fv (iqm_shader.ambient.location, 1, ambientcolor);
for (i = 0; i < MAX_IQM_LIGHTS; i++) {
quat_t val;
lightpar_t *l = &iqm_shader.lights[i];
if (!lights[i])
break;
VectorSubtract (lights[i]->origin, ent->origin, val);
val[3] = lights[i]->radius;
qfeglUniform4fv (l->position.location, 1, val);
qfeglUniform4fv (l->color.location, 1, lights[i]->color);
}
for (; i < MAX_IQM_LIGHTS; i++) {
lightpar_t *l = &iqm_shader.lights[i];
qfeglUniform4fv (l->position.location, 1, quat_origin);
qfeglUniform4fv (l->color.location, 1, quat_origin);
}
qfeglBindBuffer (GL_ARRAY_BUFFER, glsl->vertex_array);
qfeglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, glsl->element_array);
qfeglUniformMatrix4fv (iqm_shader.mvp_matrix.location, 1, false, mvp_mat);
qfeglUniformMatrix3fv (iqm_shader.norm_matrix.location, 1, false,
norm_mat);
qfeglUniformMatrix4fv (iqm_shader.bonemats.location, iqm->num_joints,
false, (float *) frame);
qfeglVertexAttrib4fv (iqm_shader.vcolor.location, color);
set_arrays (iqm);
for (i = 0; i < iqm->num_meshes; i++) {
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglBindTexture (GL_TEXTURE_2D, glsl->textures[i]);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglBindTexture (GL_TEXTURE_2D, glsl->normmaps[i]);
qfeglDrawElements (GL_TRIANGLES, 3 * iqm->meshes[i].num_triangles,
GL_UNSIGNED_SHORT,
iqm->elements + 3 * iqm->meshes[i].first_triangle);
}
}
// All iqm models are drawn in a batch, so avoid thrashing the gl state
void
glsl_R_IQMBegin (void)
{
quat_t fog;
// pre-multiply the view and projection matricies
Mat4Mult (glsl_projection, glsl_view, iqm_vp);
qfeglUseProgram (iqm_shader.program);
glsl_Fog_GetColor (fog);
fog[3] = glsl_Fog_GetDensity () / 64.0;
qfeglUniform4fv (iqm_shader.fog.location, 1, fog);
qfeglUniform1i (iqm_shader.texture.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglUniform1i (iqm_shader.normalmap.location, 1);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglEnable (GL_TEXTURE_2D);
}
void
glsl_R_IQMEnd (void)
{
int i;
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
qfeglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
for (i = 0; i <= IQM_COLOR; i++)
qfeglDisableVertexAttribArray (vertex_attribs[i].attr->location);
}
Reference in a new issue View git blame Copy permalink