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_alias.c

379 lines
11 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
#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
Do not try to lerp entities when their model changes. This avoids sending invalid pose data to the renderer. The symptom was a vertex array offset higher than the vertex array size. Discovered by calim of nouveau while he was debugging a driver problem found by QF. Many thanks.
2012-04-25 01:09:23 +00:00
#include "QF/cvar.h"
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 skin support. I had this lying around for a while since it was more important to get other things working first.
2012-01-22 06:48:32 +00:00
#include "QF/skin.h"
Do not try to lerp entities when their model changes. This avoids sending invalid pose data to the renderer. The symptom was a vertex array offset higher than the vertex array size. Discovered by calim of nouveau while he was debugging a driver problem found by QF. Many thanks.
2012-04-25 01:09:23 +00:00
#include "QF/sys.h"
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
#include "QF/scene/component.h"
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +00:00
#include "QF/scene/entity.h"
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
#include "QF/scene/scene.h"
[scene] Rename libQFentity to libQFscene And start working on scene management.
2021-07-24 05:19:52 +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
#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"
Take the first step towards render plugins. No clients link. Even if they did, nothing would work.
2012-02-14 08:28:09 +00:00
#include "r_internal.h"
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
static const char *alias_vert_effects[] =
{
"QuakeForge.Vertex.mdl",
Use the new shader system in the bsp renderer. It mostly works. Skybox is untested, and water surfaces are broken.
2013-06-07 08:12:44 +00:00
0
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
};
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
static const char *alias_frag_effects[] =
{
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.colormap",
"QuakeForge.Fragment.mdl",
Use the new shader system in the bsp renderer. It mostly works. Skybox is untested, and water surfaces are broken.
2013-06-07 08:12:44 +00:00
0
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
};
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
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 colormap;
shaderparam_t skin;
shaderparam_t ambient;
shaderparam_t shadelight;
shaderparam_t lightvec;
Implement global fog. Sprites and particles don't seem to be getting fogged correctly, but bsp and alias models are working.
2012-01-29 01:27:28 +00:00
shaderparam_t fog;
Load the alias model shaders.
2012-01-02 02:18:34 +00:00
} 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
{"colormap", 1},
{"skin", 1},
{"ambient", 1},
{"shadelight", 1},
{"lightvec", 1},
Implement global fog. Sprites and particles don't seem to be getting fogged correctly, but bsp and alias models are working.
2012-01-29 01:27:28 +00:00
{"fog", 1},
Load the alias model shaders.
2012-01-02 02:18:34 +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
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
static mat4f_t alias_vp;
Build the vertex normals texture.
2012-01-02 04:15:51 +00:00
Remove VISIBLE from the files that will go into the plugins.
2012-02-18 13:28:42 +00:00
void
Rename the public symbols for gl, glsl and sw32. Evil hack, but it does the job.
2012-02-22 07:32:34 +00:00
glsl_R_InitAlias (void)
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
{
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
shader_t *vert_shader, *frag_shader;
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
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
vert_shader = GLSL_BuildShader (alias_vert_effects);
frag_shader = GLSL_BuildShader (alias_frag_effects);
vert = GLSL_CompileShader ("quakemdl.vert", vert_shader,
Clean up global symbols for the glsl renderer. Where possible, symbols have been made static, prefixed with glsl_/GLSL_ or moved into the code shared by all renderers. This will make doing plugins easier but done now for link testing. The moving was done via the gl commit.
2012-02-17 09:57:13 +00:00
GL_VERTEX_SHADER);
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
frag = GLSL_CompileShader ("quakemdl.frag", frag_shader,
Clean up global symbols for the glsl renderer. Where possible, symbols have been made static, prefixed with glsl_/GLSL_ or moved into the code shared by all renderers. This will make doing plugins easier but done now for link testing. The moving was done via the gl commit.
2012-02-17 09:57:13 +00:00
GL_FRAGMENT_SHADER);
quake_mdl.program = GLSL_LinkProgram ("quakemdl", vert, frag);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.mvp_matrix);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.norm_matrix);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin_size);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.blend);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colora);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colorb);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.sta);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.stb);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normala);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.normalb);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexa);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.vertexb);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.colormap);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.skin);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.ambient);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.shadelight);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.lightvec);
GLSL_ResolveShaderParam (quake_mdl.program, &quake_mdl.fog);
Start using the new shader system. So far, alias model rendering is the only victim, but things are working, even if only color map lookup and fog blending are broken out at this stage. I expect the effect naming scheme will go through some changes until I'm happy with it.
2013-05-12 04:51:02 +00:00
GLSL_FreeShader (vert_shader);
GLSL_FreeShader (frag_shader);
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
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
calc_lighting (entity_t ent, float *ambient, float *shadelight,
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
vec3_t lightvec)
{
unsigned i;
float add;
vec3_t dist;
Call R_SetFrustum in all renderers. It turns out glsl, sw and sw32 weren't getting any benefit from R_CullBox because the frustum wasn't setup :P. Get another 8% out of bigass1 (174->184fps). bigass1 now runs 2x as fast as it did before I started this optimisation run :)
2012-07-03 06:57:33 +00:00
int light;
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
[renderer] Tidy up entity component access Since entity_t has a pointer to the registry owning the entity, there's no need to access a global to get at the registry. Also move component getting closer to where it's used.
2022-10-25 03:53:30 +00:00
transform_t transform = Entity_Transform (ent);
vec4f_t entorigin = Transform_GetWorldPosition (transform);
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +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
VectorSet ( -1, 0, 0, lightvec); //FIXME
[renderer] Move a couple functions to using vec4f_t Makes for a few less FIXMEs and better consistency with vectors.
2022-03-30 14:50:12 +00:00
light = R_LightPoint (&r_refdef.worldmodel->brush, entorigin);
[renderer] Tidy up entity component access Since entity_t has a pointer to the registry owning the entity, there's no need to access a global to get at the registry. Also move component getting closer to where it's used.
2022-10-25 03:53:30 +00:00
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer, ent.reg);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
*ambient = max (light, max (renderer->model->min_light,
renderer->min_light) * 128);
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
*shadelight = *ambient;
for (i = 0; i < r_maxdlights; i++) {
Take the first step towards render plugins. No clients link. Even if they did, nothing would work.
2012-02-14 08:28:09 +00:00
if (r_dlights[i].die >= vr_data.realtime) {
[renderer] Remove more old fields from entity_t The only transform related field remaining is old_origin. This also brings the renderer closer to using simd (lots of stuff to fix still, though).
2021-03-19 11:18:45 +00:00
VectorSubtract (entorigin, r_dlights[i].origin, dist);
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
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;
Do not try to lerp entities when their model changes. This avoids sending invalid pose data to the renderer. The symptom was a vertex array offset higher than the vertex array size. Discovered by calim of nouveau while he was debugging a driver problem found by QF. Many thanks.
2012-04-25 01:09:23 +00:00
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (developer & SYS_glsl) {
Do not try to lerp entities when their model changes. This avoids sending invalid pose data to the renderer. The symptom was a vertex array offset higher than the vertex array size. Discovered by calim of nouveau while he was debugging a driver problem found by QF. Many thanks.
2012-04-25 01:09:23 +00:00
GLint size;
qfeglGetBufferParameteriv (GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
Fix some 64-bit mingw compile issues. Just one more issue to fix (alloca), but with a hack, QF compiles (no clue yet if it works: wine doesn't seem to be an option at this stage)
2013-01-22 04:27:39 +00:00
if (size <= (intptr_t)pose_offs) {
Do not try to lerp entities when their model changes. This avoids sending invalid pose data to the renderer. The symptom was a vertex array offset higher than the vertex array size. Discovered by calim of nouveau while he was debugging a driver problem found by QF. Many thanks.
2012-04-25 01:09:23 +00:00
Sys_Printf ("Invalid pose");
pose = 0;
}
}
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (vert->location, 3, GL_UNSIGNED_SHORT,
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
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, vertex));
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (norm->location, 3, GL_SHORT,
Normalize the vertex normals. I was wondering why the lighting looked a little extreme in overkill.
2012-01-05 03:45:43 +00:00
1, sizeof (aliasvrt_t),
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
pose_offs + field_offset (aliasvrt_t, normal));
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (st->location, 2, GL_SHORT,
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
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
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
glsl_R_DrawAlias (entity_t ent)
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
#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];
Enable lerping of alias models. Done in hardware }:>
2012-01-04 07:36:43 +00:00
float blend;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
aliashdr_t *hdr;
vec_t norm_mat[9];
Make a start on skin support. I had this lying around for a while since it was more important to get other things working first.
2012-01-22 06:48:32 +00:00
int skin_tex;
Make top/bottom color work for GLSL. Works quite nicely (love those colormaps).
2012-01-23 10:24:12 +00:00
int colormap;
Enable lerping of alias models. Done in hardware }:>
2012-01-04 07:36:43 +00:00
aliasvrt_t *pose1 = 0; // VBO's are null based
aliasvrt_t *pose2 = 0; // VBO's are null based
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
mat4f_t worldMatrix;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
calc_lighting (ent, &ambient, &shadelight, lightvec);
[renderer] Tidy up entity component access Since entity_t has a pointer to the registry owning the entity, there's no need to access a global to get at the registry. Also move component getting closer to where it's used.
2022-10-25 03:53:30 +00:00
renderer_t *renderer = Ent_GetComponent (ent.id, scene_renderer, ent.reg);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
model_t *model = renderer->model;
Make alias model caching optional. For now, only the glsl loader disables caching, but it stores the frame vertices in GL memory, so its hunk usage is relatively lower (and will be lower still when I get skins sorted out).
2012-01-17 02:44:28 +00:00
if (!(hdr = model->aliashdr))
hdr = Cache_Get (&model->cache);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[renderer] Tidy up entity component access Since entity_t has a pointer to the registry owning the entity, there's no need to access a global to get at the registry. Also move component getting closer to where it's used.
2022-10-25 03:53:30 +00:00
transform_t transform = Entity_Transform (ent);
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
Transform_GetWorldMatrix (transform, worldMatrix);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
// we need only the rotation for normals.
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
VectorCopy (worldMatrix[0], norm_mat + 0);
VectorCopy (worldMatrix[1], norm_mat + 3);
VectorCopy (worldMatrix[2], norm_mat + 6);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
// ent model scaling and offset
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
mat4f_t mvp_mat = {
{ hdr->mdl.scale[0], 0, 0, 0 },
{ 0, hdr->mdl.scale[1], 0, 0 },
{ 0, 0, hdr->mdl.scale[2], 0 },
{ hdr->mdl.scale_origin[0], hdr->mdl.scale_origin[1],
hdr->mdl.scale_origin[2], 1 },
};
mmulf (mvp_mat, worldMatrix, mvp_mat);
mmulf (mvp_mat, alias_vp, mvp_mat);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[renderer] Tidy up entity component access Since entity_t has a pointer to the registry owning the entity, there's no need to access a global to get at the registry. Also move component getting closer to where it's used.
2022-10-25 03:53:30 +00:00
animation_t *animation = Ent_GetComponent (ent.id, scene_animation,
ent.reg);
Make top/bottom color work for GLSL. Works quite nicely (love those colormaps).
2012-01-23 10:24:12 +00:00
colormap = glsl_colormap;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
if (renderer->skin && renderer->skin->auxtex)
colormap = renderer->skin->auxtex;
if (renderer->skin && renderer->skin->texnum) {
skin_t *skin = renderer->skin;
Gut most of the old skin code. Custom skins are smashed on most targets. Player colors don't work, etc. However, this will let me do a much cleaner implementation.
2012-01-23 07:16:30 +00:00
skin_tex = skin->texnum;
Make a start on skin support. I had this lying around for a while since it was more important to get other things working first.
2012-01-22 06:48:32 +00:00
} else {
maliasskindesc_t *skindesc;
[scene] Make entity_t just an entity id for ECS This puts the hierarchy (transform) reference, animation, visibility, renderer, active, and old_origin data in separate components. There are a few bugs (crashes on grenade explosions in gl/glsl/vulkan, immediately in sw, reasons known, missing brush models in vulkan). While quake doesn't really need an ECS, the direction I want to take QF does, and it does seem to have improved memory bandwidth a little (uncertain). However, there's a lot more work to go (especially fixing the above bugs), but this seems to be a good start.
2022-10-23 01:32:09 +00:00
skindesc = R_AliasGetSkindesc (animation, renderer->skinnum, hdr);
Make a start on skin support. I had this lying around for a while since it was more important to get other things working first.
2012-01-22 06:48:32 +00:00
skin_tex = skindesc->texnum;
}
[renderer] Remove currententity from non-sw renderers Really needed only for vulkan, but removing currententity from gl and glsl made testing easier.
2021-07-22 06:39:28 +00:00
blend = R_AliasGetLerpedFrames (animation, hdr);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[renderer] Remove currententity from non-sw renderers Really needed only for vulkan, but removing currententity from gl and glsl made testing easier.
2021-07-22 06:39:28 +00:00
pose1 += animation->pose1 * hdr->poseverts;
pose2 += animation->pose2 * 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;
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglBindTexture (GL_TEXTURE_2D, colormap);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglBindTexture (GL_TEXTURE_2D, skin_tex);
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
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglBindBuffer (GL_ARRAY_BUFFER, hdr->posedata);
qfeglBindBuffer (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
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttrib4fv (quake_mdl.colora.location, color);
qfeglVertexAttrib4fv (quake_mdl.colorb.location, color);
qfeglUniform1f (quake_mdl.blend.location, blend);
qfeglUniform1f (quake_mdl.ambient.location, ambient);
qfeglUniform1f (quake_mdl.shadelight.location, shadelight);
qfeglUniform3fv (quake_mdl.lightvec.location, 1, lightvec);
qfeglUniform2fv (quake_mdl.skin_size.location, 1, skin_size);
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
qfeglUniformMatrix4fv (quake_mdl.mvp_matrix.location, 1, false,
Update vec3_t/vec4f_t hacks to work with clang Still work with gcc, of course, and I still need to fix them properly, but now they're actually slightly easier to find as they all have vec_t and FIXME on the same line.
2022-03-30 15:07:20 +00:00
(vec_t*)&mvp_mat[0]);//FIXME
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglUniformMatrix3fv (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
Enable lerping of alias models. Done in hardware }:>
2012-01-04 07:36:43 +00:00
set_arrays (&quake_mdl.vertexa, &quake_mdl.normala, &quake_mdl.sta, pose1);
set_arrays (&quake_mdl.vertexb, &quake_mdl.normalb, &quake_mdl.stb, pose2);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDrawElements (GL_TRIANGLES, 3 * hdr->mdl.numtris,
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_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);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDrawElements (GL_TRIANGLES,
Add my test tetrahedrons.
2012-01-02 14:32:30 +00:00
sizeof (debug_indices) / sizeof (debug_indices[0]),
GL_UNSIGNED_SHORT, debug_indices);
#endif
Make alias model caching optional. For now, only the glsl loader disables caching, but it stores the frame vertices in GL memory, so its hunk usage is relatively lower (and will be lower still when I get skins sorted out).
2012-01-17 02:44:28 +00:00
if (!model->aliashdr)
Cache_Release (&model->cache);
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
Rename the public symbols for gl, glsl and sw32. Evil hack, but it does the job.
2012-02-22 07:32:34 +00:00
glsl_R_AliasBegin (void)
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
{
Implement global fog. Sprites and particles don't seem to be getting fogged correctly, but bsp and alias models are working.
2012-01-29 01:27:28 +00:00
quat_t fog;
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
// pre-multiply the view and projection matricies
[renderer] Clean up entity_t to a certain extent This is the first step towards component-based entities. There's still some transform-related stuff in the struct that needs to be moved, but it's all entirely client related (rather than renderer) and will probably go into a "client" component. Also, the current components are directly included structs rather than references as I didn't want to deal with the object management at this stage. As part of the process (because transforms use simd) this also starts the process of moving QF to using simd for vectors and matrices. There's now a mess of simd and sisd code mixed together, but it works surprisingly well together.
2021-03-09 14:52:40 +00:00
mmulf (alias_vp, glsl_projection, glsl_view);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglUseProgram (quake_mdl.program);
qfeglEnableVertexAttribArray (quake_mdl.vertexa.location);
qfeglEnableVertexAttribArray (quake_mdl.vertexb.location);
qfeglEnableVertexAttribArray (quake_mdl.normala.location);
qfeglEnableVertexAttribArray (quake_mdl.normalb.location);
qfeglEnableVertexAttribArray (quake_mdl.sta.location);
qfeglEnableVertexAttribArray (quake_mdl.stb.location);
qfeglDisableVertexAttribArray (quake_mdl.colora.location);
qfeglDisableVertexAttribArray (quake_mdl.colorb.location);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
[renderer] Merge the fog support code GL still has its own functions for enabling and disabling fog while rendering, but GLSL doesn't need such (thanks to the shaders), nor will vulkan (and the software renderers don't support fog).
2022-03-07 17:10:47 +00:00
Fog_GetColor (fog);
fog[3] = Fog_GetDensity () / 64.0;
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglUniform4fv (quake_mdl.fog.location, 1, fog);
Implement global fog. Sprites and particles don't seem to be getting fogged correctly, but bsp and alias models are working.
2012-01-29 01:27:28 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglUniform1i (quake_mdl.colormap.location, 1);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglEnable (GL_TEXTURE_2D);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglUniform1i (quake_mdl.skin.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
}
void
Rename the public symbols for gl, glsl and sw32. Evil hack, but it does the job.
2012-02-22 07:32:34 +00:00
glsl_R_AliasEnd (void)
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
{
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglBindBuffer (GL_ARRAY_BUFFER, 0);
qfeglBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);
qfeglDisableVertexAttribArray (quake_mdl.vertexa.location);
qfeglDisableVertexAttribArray (quake_mdl.vertexb.location);
qfeglDisableVertexAttribArray (quake_mdl.normala.location);
qfeglDisableVertexAttribArray (quake_mdl.normalb.location);
qfeglDisableVertexAttribArray (quake_mdl.sta.location);
qfeglDisableVertexAttribArray (quake_mdl.stb.location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
qfeglActiveTexture (GL_TEXTURE0 + 1);
qfeglDisable (GL_TEXTURE_2D);
Hook in alias model drawing. Nothing is visible yet.
2012-01-02 10:15:01 +00:00
}
Reference in a new issue Copy permalink