qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quakeforge/libs/video/renderer/glsl/glsl_alias.c

325 lines
9.5 KiB
C
Raw Normal View History

Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
/*
glsl_alias.c
GLSL Alias model rendering
Copyright (C) 2012 Bill Currie <bill@taniwha.org>
Author: Bill Currie <bill@taniwha.org>
Date: 2012/1/1
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
static __attribute__ ((used)) const char rcsid[] = "$Id$";
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
#include <stdlib.h>
Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
#include "QF/render.h"
Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
#include "QF/GLSL/defines.h"
#include "QF/GLSL/funcs.h"
#include "QF/GLSL/qf_alias.h"
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
#include "QF/GLSL/qf_textures.h"
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
#include "QF/GLSL/qf_vid.h"
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
#include "r_local.h"
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
static const char quakemdl_vert[] =
#include "quakemdl.vc"
;
static const char quakemdl_frag[] =
#include "quakemdl.fc"
;
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t norm_matrix;
Load all the alias vertex data as bytes. I had forgotten I wanted to do it this way.
2012-01-02 04:41:12 +00:00
shaderparam_t skin_size;
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
shaderparam_t blend;
shaderparam_t colora;
shaderparam_t colorb;
shaderparam_t sta;
shaderparam_t stb;
shaderparam_t normala;
shaderparam_t normalb;
shaderparam_t vertexa;
shaderparam_t vertexb;
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
shaderparam_t palette;
shaderparam_t colormap;
shaderparam_t skin;
shaderparam_t ambient;
shaderparam_t shadelight;
shaderparam_t lightvec;
} quake_mdl = {
0,
{"mvp_mat", 1},
{"norm_mat", 1},
Load all the alias vertex data as bytes. I had forgotten I wanted to do it this way.
2012-01-02 04:41:12 +00:00
{"skin_size", 1},
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
{"blend", 1},
{"vcolora", 0},
{"vcolorb", 0},
{"vsta", 0},
{"vstb", 0},
{"vnormala", 0},
{"vnormalb", 0},
{"vertexa", 0},
{"vertexb", 0},
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
{"palette", 1},
{"colormap", 1},
{"skin", 1},
{"ambient", 1},
{"shadelight", 1},
{"lightvec", 1},
};
Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
Re-enable the matrix optimizations. Turns out my concatenations were correct.
2012-01-03 09:09:33 +00:00
static mat4_t alias_vp;
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
VISIBLE void
R_InitAlias (void)
{
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
int vert;
int frag;
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
vert = GL_CompileShader ("quakemdl.vert", quakemdl_vert, GL_VERTEX_SHADER);
frag = GL_CompileShader ("quakemdl.frag", quakemdl_frag,
GL_FRAGMENT_SHADER);
quake_mdl.program = GL_LinkProgram ("quakemdl", vert, frag);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.mvp_matrix);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.norm_matrix);
Load all the alias vertex data as bytes. I had forgotten I wanted to do it this way.
2012-01-02 04:41:12 +00:00
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin_size);
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.blend);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colora);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colorb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.sta);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.stb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normala);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normalb);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexa);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexb);
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.palette);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colormap);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.ambient);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.shadelight);
GL_ResolveShaderParam (quake_mdl.program, &quake_mdl.lightvec);
Make a start on alias model rendering. The vertex and fragment shaders are written, and R_InitAlias is stubbed, but that's it so far.
2012-01-01 14:58:12 +00:00
}
Implement dynamic lighting. This uses the same calculations as the software renderer. However, as the lightmap calculations are not done yet, if there is no dlight in the vicinity, there will be no light. demo1 is pretty cool to watch :)
2012-01-03 11:36:07 +00:00
static void
calc_lighting (entity_t *ent, float *ambient, float *shadelight,
vec3_t lightvec)
{
unsigned i;
float add;
vec3_t dist;
VectorSet ( -1, 0, 0, lightvec); //FIXME
*ambient = max (R_LightPoint (ent->origin), max (ent->model->min_light,
ent->min_light) * 128);
*shadelight = *ambient;
for (i = 0; i < r_maxdlights; i++) {
if (r_dlights[i].die >= r_realtime) {
VectorSubtract (ent->origin, r_dlights[i].origin, dist);
add = r_dlights[i].radius - VectorLength (dist);
if (add > 0)
*ambient += add;
}
}
if (*ambient >= 128)
*ambient = 128;
if (*shadelight > 192 - *ambient)
*shadelight = 192 - *ambient;
}
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
static void
set_arrays (const shaderparam_t *vert, const shaderparam_t *norm,
const shaderparam_t *st, aliasvrt_t *pose)
{
byte *pose_offs = (byte *) pose;
qfglVertexAttribPointer (vert->location, 3, GL_UNSIGNED_BYTE,
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, vertex));
qfglVertexAttribPointer (norm->location, 3, GL_SHORT,
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, normal));
qfglVertexAttribPointer (st->location, 2, GL_SHORT,
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, st));
}
Re-enable the matrix optimizations. Turns out my concatenations were correct.
2012-01-03 09:09:33 +00:00
//#define TETRAHEDRON
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
void
R_DrawAlias (void)
{
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
#ifdef TETRAHEDRON
static aliasvrt_t debug_verts[] = {
Upload the normals with the vertex data. Not all hardware can access a texture sampler from the vertex shader, and I don't want multiple paths this early in the game. Now, vertex normals are uploaded as shorts. Should be 14 bytes per vertex (was 10, could have been 8 if I had put the normal index with the vertex rather than st).
2012-01-04 00:42:00 +00:00
{{ 0, 0}, {-18918,-18918,-18918}, { 0, 0, 0}},
{{ 0,300}, { 18918, 18918,-18918}, {255,255, 0}},
{{300,300}, {-18918, 18918, 18918}, { 0,255,255}},
{{300, 0}, { 18918,-18918, 18918}, {255, 0,255}},
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
};
static GLushort debug_indices[] = {
0, 1, 2,
0, 3, 1,
1, 3, 2,
0, 2, 3,
};
#endif
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
static quat_t color = { 1, 1, 1, 1};
Implement dynamic lighting. This uses the same calculations as the software renderer. However, as the lightmap calculations are not done yet, if there is no dlight in the vicinity, there will be no light. demo1 is pretty cool to watch :)
2012-01-03 11:36:07 +00:00
static vec3_t lightvec;
float ambient;
float shadelight;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
float skin_size[2];
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
float blend = 0.0;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
entity_t *ent = currententity;
model_t *model = ent->model;
aliashdr_t *hdr;
vec_t norm_mat[9];
mat4_t mvp_mat;
maliasskindesc_t *skin;
aliasvrt_t *pose = 0; // VBO's are null based
maliasframedesc_t *frame;
hdr = Cache_Get (&model->cache);
Implement dynamic lighting. This uses the same calculations as the software renderer. However, as the lightmap calculations are not done yet, if there is no dlight in the vicinity, there will be no light. demo1 is pretty cool to watch :)
2012-01-03 11:36:07 +00:00
calc_lighting (ent, &ambient, &shadelight, lightvec);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
// 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);
// ent model scaling and offset
Mat4Zero (mvp_mat);
mvp_mat[0] = hdr->mdl.scale[0];
mvp_mat[5] = hdr->mdl.scale[1];
mvp_mat[10] = hdr->mdl.scale[2];
mvp_mat[15] = 1;
VectorCopy (hdr->mdl.scale_origin, mvp_mat + 12);
Mat4Mult (ent->transform, mvp_mat, mvp_mat);
Re-enable the matrix optimizations. Turns out my concatenations were correct.
2012-01-03 09:09:33 +00:00
Mat4Mult (alias_vp, mvp_mat, mvp_mat);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
skin = R_AliasGetSkindesc (ent->skinnum, hdr);
frame = R_AliasGetFramedesc (ent->frame, hdr);
Remove the hedgehogs from the garden. While the first frame was fine, any subsequent ones were not. I had forgotten that hdr->poseverts held the edited vertex count rather than hdr->mdl.numverts.
2012-01-03 09:11:39 +00:00
pose += frame->firstpose * hdr->poseverts;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
skin_size[0] = hdr->mdl.skinwidth;
skin_size[1] = hdr->mdl.skinheight;
qfglBindTexture (GL_TEXTURE_2D, skin->texnum);
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
#ifndef TETRAHEDRON
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglBindBuffer (GL_ARRAY_BUFFER, hdr->posedata);
qfglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, hdr->commands);
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
#endif
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
qfglVertexAttrib4fv (quake_mdl.colora.location, color);
qfglVertexAttrib4fv (quake_mdl.colorb.location, color);
qfglUniform1f (quake_mdl.blend.location, blend);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglUniform1f (quake_mdl.ambient.location, ambient);
qfglUniform1f (quake_mdl.shadelight.location, shadelight);
qfglUniform3fv (quake_mdl.lightvec.location, 1, lightvec);
qfglUniform2fv (quake_mdl.skin_size.location, 1, skin_size);
Actually load up the mvp and normal matrices. Rather critical. I thought I'd done that :/
2012-01-02 13:38:52 +00:00
qfglUniformMatrix4fv (quake_mdl.mvp_matrix.location, 1, false, mvp_mat);
qfglUniformMatrix3fv (quake_mdl.norm_matrix.location, 1, false, norm_mat);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
#ifndef TETRAHEDRON
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
set_arrays (&quake_mdl.vertexa, &quake_mdl.normala, &quake_mdl.sta, pose);
set_arrays (&quake_mdl.vertexb, &quake_mdl.normalb, &quake_mdl.stb, pose);
qfglDrawElements (GL_TRIANGLES, 3 * hdr->mdl.numtris,
GL_UNSIGNED_SHORT, 0);
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
#else
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
set_arrays (&quake_mdl.vertexa, &quake_mdl.normala, &quake_mdl.sta,
debug_verts);
set_arrays (&quake_mdl.vertexb, &quake_mdl.normalb, &quake_mdl.stb,
debug_verts);
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
qfglDrawElements (GL_TRIANGLES,
sizeof (debug_indices) / sizeof (debug_indices[0]),
GL_UNSIGNED_SHORT, debug_indices);
#endif
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
}
// All alias models are drawn in a batch, so avoid thrashing the gl state
void
R_AliasBegin (void)
{
// pre-multiply the view and projection matricies
Re-enable the matrix optimizations. Turns out my concatenations were correct.
2012-01-03 09:09:33 +00:00
Mat4Mult (glsl_projection, glsl_view, alias_vp);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglUseProgram (quake_mdl.program);
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
qfglEnableVertexAttribArray (quake_mdl.vertexa.location);
qfglEnableVertexAttribArray (quake_mdl.vertexb.location);
qfglEnableVertexAttribArray (quake_mdl.normala.location);
qfglEnableVertexAttribArray (quake_mdl.normalb.location);
qfglEnableVertexAttribArray (quake_mdl.sta.location);
qfglEnableVertexAttribArray (quake_mdl.stb.location);
qfglDisableVertexAttribArray (quake_mdl.colora.location);
qfglDisableVertexAttribArray (quake_mdl.colorb.location);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
Upload the normals with the vertex data. Not all hardware can access a texture sampler from the vertex shader, and I don't want multiple paths this early in the game. Now, vertex normals are uploaded as shorts. Should be 14 bytes per vertex (was 10, could have been 8 if I had put the normal index with the vertex rather than st).
2012-01-04 00:42:00 +00:00
qfglUniform1i (quake_mdl.colormap.location, 1);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglActiveTexture (GL_TEXTURE0 + 1);
qfglEnable (GL_TEXTURE_2D);
qfglBindTexture (GL_TEXTURE_2D, glsl_colormap);
Upload the normals with the vertex data. Not all hardware can access a texture sampler from the vertex shader, and I don't want multiple paths this early in the game. Now, vertex normals are uploaded as shorts. Should be 14 bytes per vertex (was 10, could have been 8 if I had put the normal index with the vertex rather than st).
2012-01-04 00:42:00 +00:00
qfglUniform1i (quake_mdl.palette.location, 2);
qfglActiveTexture (GL_TEXTURE0 + 2);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglEnable (GL_TEXTURE_2D);
qfglBindTexture (GL_TEXTURE_2D, glsl_palette);
qfglUniform1i (quake_mdl.skin.location, 0);
qfglActiveTexture (GL_TEXTURE0 + 0);
qfglEnable (GL_TEXTURE_2D);
}
void
R_AliasEnd (void)
{
qfglBindBuffer (GL_ARRAY_BUFFER, 0);
qfglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
Rework the alias vertex shader and rendering code for lerping. Lerping isn't actually done yet (need to get both poses and blend), but this still renders correctly with blend forced to 0.0.
2012-01-04 05:35:34 +00:00
qfglDisableVertexAttribArray (quake_mdl.vertexa.location);
qfglDisableVertexAttribArray (quake_mdl.vertexb.location);
qfglDisableVertexAttribArray (quake_mdl.normala.location);
qfglDisableVertexAttribArray (quake_mdl.normalb.location);
qfglDisableVertexAttribArray (quake_mdl.sta.location);
qfglDisableVertexAttribArray (quake_mdl.stb.location);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
qfglActiveTexture (GL_TEXTURE0 + 0);
qfglDisable (GL_TEXTURE_2D);
qfglActiveTexture (GL_TEXTURE0 + 1);
qfglDisable (GL_TEXTURE_2D);
qfglActiveTexture (GL_TEXTURE0 + 2);
qfglDisable (GL_TEXTURE_2D);
qfglActiveTexture (GL_TEXTURE0 + 3);
qfglDisable (GL_TEXTURE_2D);
}