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

442 lines
12 KiB
C
Raw Normal View History

Split out the particle code.
2011-12-25 22:50:05 +00:00
/*
[particles] Create a psystem object This takes care of the global variables to a point (there is still the global struct shared between the non-vulkan renderers), but it also takes care of glsl's points-only rendering.
2021-12-19 05:47:25 +00:00
glsl_particles.c
Split out the particle code.
2011-12-25 22:50:05 +00:00
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
OpenGL particle system.
Split out the particle code.
2011-12-25 22:50:05 +00:00
Copyright (C) 1996-1997 Id Software, Inc.
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
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
# include <string.h>
Split out the particle code.
2011-12-25 22:50:05 +00:00
#endif
#ifdef HAVE_STRINGS_H
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
# include <strings.h>
Split out the particle code.
2011-12-25 22:50:05 +00:00
#endif
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
#include <stdlib.h>
#include "QF/cmd.h"
Split out the particle code.
2011-12-25 22:50:05 +00:00
#include "QF/cvar.h"
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
#include "QF/image.h"
Use the Mersenne Twister for particles. The seed is currently 0xdeadbeef, but I intend on fixing that soon. Now the particle velocities and origins use fully independent bits (though a big chunk is wasted right now).
2013-01-21 11:06:54 +00:00
#include "QF/mersenne.h"
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
#include "QF/qargs.h"
#include "QF/quakefs.h"
Split out the particle code.
2011-12-25 22:50:05 +00:00
#include "QF/render.h"
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
#include "QF/sys.h"
#include "QF/va.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"
Make a clean break heading for GLES compatibility. Add GLSL directory to QF and use it for all gsls based code (instead of GL). defines.h, types.h and funcs.h are derived from gl2.h from khronos. Text drawing now uses triangles instead of quads.
2011-12-26 07:08:55 +00:00
#include "QF/GLSL/defines.h"
#include "QF/GLSL/funcs.h"
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
//#include "QF/GL/qf_explosions.h"
#include "QF/GLSL/qf_particles.h"
#include "QF/GLSL/qf_textures.h"
#include "QF/GLSL/qf_vid.h"
Split out the particle code.
2011-12-25 22:50:05 +00:00
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"
Split out the particle code.
2011-12-25 22:50:05 +00:00
Enable the point size shader variable. This is a rather "evil" hack because GLES doesn't seem to need GL_VERTEX_PROGRAM_POINT_SIZE, but GL does, and all my work is currently done in GL rather than GLES. Point particles now work, but the sizes are all wrong.
2012-01-21 12:54:36 +00:00
//FIXME not part of GLES, but needed for GL
#ifndef GL_VERTEX_PROGRAM_POINT_SIZE
# define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
#endif
[glsl] Update particle arrays when maximum changes The cvar setup for particles is a bit wonky in that the arrays get initialized using the default max particle count but never updated. Though things could be improved some more, this solution works (and has been more or less copied to gl, but I couldn't reproduce the crash there, or even the valgrind error).
2022-03-25 05:48:01 +00:00
static uint32_t maxparticles;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
static GLushort *pVAindices;
static partvert_t *particleVertexArray;
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
static GLuint part_tex;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
static const char *particle_point_vert_effects[] =
{
"QuakeForge.Vertex.particle.point",
0
};
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
static const char *particle_point_frag_effects[] =
{
Remove redundant fog and palette shader code.
2014-01-28 04:00:28 +00:00
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.palette",
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
"QuakeForge.Fragment.particle.point",
0
};
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
static const char *particle_textured_vert_effects[] =
{
"QuakeForge.Vertex.particle.textured",
0
};
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
static const char *particle_textured_frag_effects[] =
{
Remove redundant fog and palette shader code.
2014-01-28 04:00:28 +00:00
"QuakeForge.Fragment.fog",
"QuakeForge.Fragment.palette",
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
"QuakeForge.Fragment.particle.textured",
0
};
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t vertex;
shaderparam_t palette;
shaderparam_t color;
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;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
} quake_point = {
0,
{"mvp_mat", 1},
{"vertex", 0},
{"palette", 1},
{"vcolor", 0},
Fix the missing fog on particles and sprites. Bah, definitely need a metter method of parameter interrogation.
2012-01-29 01:35:23 +00:00
{"fog", 1},
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
};
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
static struct {
int program;
shaderparam_t mvp_matrix;
shaderparam_t st;
shaderparam_t vertex;
shaderparam_t color;
shaderparam_t texture;
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;
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
} quake_part = {
0,
{"mvp_mat", 1},
{"vst", 0},
{"vertex", 0},
{"vcolor", 0},
{"texture", 1},
Fix the missing fog on particles and sprites. Bah, definitely need a metter method of parameter interrogation.
2012-01-29 01:35:23 +00:00
{"fog", 1},
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
};
[glsl] Update particle arrays when maximum changes The cvar setup for particles is a bit wonky in that the arrays get initialized using the default max particle count but never updated. Though things could be improved some more, this solution works (and has been more or less copied to gl, but I couldn't reproduce the crash there, or even the valgrind error).
2022-03-25 05:48:01 +00:00
static void
alloc_arrays (psystem_t *ps)
{
if (ps->maxparticles > maxparticles) {
maxparticles = ps->maxparticles;
if (particleVertexArray)
free (particleVertexArray);
[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
printf ("alloc_arrays: %d\n", ps->maxparticles);
[glsl] Update particle arrays when maximum changes The cvar setup for particles is a bit wonky in that the arrays get initialized using the default max particle count but never updated. Though things could be improved some more, this solution works (and has been more or less copied to gl, but I couldn't reproduce the crash there, or even the valgrind error).
2022-03-25 05:48:01 +00:00
particleVertexArray = calloc (ps->maxparticles * 4,
sizeof (partvert_t));
if (pVAindices)
free (pVAindices);
pVAindices = calloc (ps->maxparticles * 6, sizeof (GLushort));
for (uint32_t i = 0; i < ps->maxparticles; i++) {
pVAindices[i * 6 + 0] = i * 4 + 0;
pVAindices[i * 6 + 1] = i * 4 + 1;
pVAindices[i * 6 + 2] = i * 4 + 2;
pVAindices[i * 6 + 3] = i * 4 + 0;
pVAindices[i * 6 + 4] = i * 4 + 2;
pVAindices[i * 6 + 5] = i * 4 + 3;
}
}
}
[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
static void
glsl_particles_f (void *data, const cvar_t *cvar)
{
alloc_arrays (&r_psystem);//FIXME
}
Split out the particle code.
2011-12-25 22:50:05 +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_InitParticles (void)
Split out the particle code.
2011-12-25 22:50:05 +00:00
{
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
shader_t *vert_shader, *frag_shader;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
int vert;
int frag;
Print out the point size range. I'm not sure if there's a bug in mesa, or if I'm doing something wrong, but GL_POINTS doesn't seem to be working properly. I get the points, but writing to gl_PointSize doesn't make a difference despite the size range being 1-255.
2012-01-21 06:48:21 +00:00
float v[2] = {0, 0};
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
byte data[64][64][2];
tex_t *tex;
Print out the point size range. I'm not sure if there's a bug in mesa, or if I'm doing something wrong, but GL_POINTS doesn't seem to be working properly. I get the points, but writing to gl_PointSize doesn't make a difference despite the size range being 1-255.
2012-01-21 06:48:21 +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
Cvar_AddListener (Cvar_FindVar ("r_particles"), glsl_particles_f, 0);
Cvar_AddListener (Cvar_FindVar ("r_particles_max"), glsl_particles_f, 0);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglEnable (GL_VERTEX_PROGRAM_POINT_SIZE);
qfeglGetFloatv (GL_ALIASED_POINT_SIZE_RANGE, v);
[util] Make developer flag names easier to manage They're now an enum, and the flag part of the name is all lowercase, but now the flag definitions and names list will never get out of sync.
2021-03-29 10:58:00 +00:00
Sys_MaskPrintf (SYS_glsl, "point size: %g - %g\n", v[0], v[1]);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
vert_shader = GLSL_BuildShader (particle_point_vert_effects);
frag_shader = GLSL_BuildShader (particle_point_frag_effects);
vert = GLSL_CompileShader ("quakepnt.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);
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
frag = GLSL_CompileShader ("quakepnt.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_point.program = GLSL_LinkProgram ("quakepoint", vert, frag);
GLSL_ResolveShaderParam (quake_point.program, &quake_point.mvp_matrix);
GLSL_ResolveShaderParam (quake_point.program, &quake_point.vertex);
GLSL_ResolveShaderParam (quake_point.program, &quake_point.palette);
GLSL_ResolveShaderParam (quake_point.program, &quake_point.color);
GLSL_ResolveShaderParam (quake_point.program, &quake_point.fog);
Use the new shader system for point particles.
2014-01-28 03:08:53 +00:00
GLSL_FreeShader (vert_shader);
GLSL_FreeShader (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
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
vert_shader = GLSL_BuildShader (particle_textured_vert_effects);
frag_shader = GLSL_BuildShader (particle_textured_frag_effects);
vert = GLSL_CompileShader ("quakepar.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);
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
frag = GLSL_CompileShader ("quakepar.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_part.program = GLSL_LinkProgram ("quakepart", vert, frag);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.mvp_matrix);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.st);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.vertex);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.color);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.texture);
GLSL_ResolveShaderParam (quake_part.program, &quake_part.fog);
Use the new shader system for textured particles.
2014-01-28 03:16:52 +00:00
GLSL_FreeShader (vert_shader);
GLSL_FreeShader (frag_shader);
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
memset (data, 0, sizeof (data));
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglGenTextures (1, &part_tex);
qfeglBindTexture (GL_TEXTURE_2D, part_tex);
qfeglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qfeglTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qfeglTexImage2D (GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 64, 64, 0,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data);
tex = R_DotParticleTexture ();
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 32, 32, GL_LUMINANCE_ALPHA,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
GL_UNSIGNED_BYTE, tex->data);
free (tex);
tex = R_SparkParticleTexture ();
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglTexSubImage2D (GL_TEXTURE_2D, 0, 32, 0, 32, 32, GL_LUMINANCE_ALPHA,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
GL_UNSIGNED_BYTE, tex->data);
free (tex);
tex = R_SmokeParticleTexture ();
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglTexSubImage2D (GL_TEXTURE_2D, 0, 0, 32, 32, 32, GL_LUMINANCE_ALPHA,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
GL_UNSIGNED_BYTE, tex->data);
free (tex);
[glsl] Update particle arrays when maximum changes The cvar setup for particles is a bit wonky in that the arrays get initialized using the default max particle count but never updated. Though things could be improved some more, this solution works (and has been more or less copied to gl, but I couldn't reproduce the crash there, or even the valgrind error).
2022-03-25 05:48:01 +00:00
alloc_arrays (&r_psystem);
Split out the particle code.
2011-12-25 22:50:05 +00:00
}
static void
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
draw_qf_particles (psystem_t *psystem)
Split out the particle code.
2011-12-25 22:50:05 +00:00
{
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
byte *at;
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
int vacount;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
float minparticledist, scale;
vec3_t up_scale, right_scale, up_right_scale, down_right_scale;
partvert_t *VA;
[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 vp_mat;
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;
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +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
mmulf (vp_mat, glsl_projection, glsl_view);
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDepthMask (GL_FALSE);
qfeglUseProgram (quake_part.program);
qfeglEnableVertexAttribArray (quake_part.vertex.location);
qfeglEnableVertexAttribArray (quake_part.color.location);
qfeglEnableVertexAttribArray (quake_part.st.location);
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +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_part.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
[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_part.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*)&vp_mat[0]);//FIXME
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +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_part.texture.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, part_tex);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
// LordHavoc: particles should not affect zbuffer
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDepthMask (GL_FALSE);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
minparticledist = DotProduct (r_refdef.frame.position,
[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
r_refdef.frame.forward)
+ r_particles_nearclip;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
vacount = 0;
VA = particleVertexArray;
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
for (unsigned i = 0; i < psystem->numparticles; i++) {
particle_t *p = &psystem->particles[i];
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
// Don't render particles too close to us.
// Note, we must still do physics and such on them.
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
if (!(DotProduct (p->pos, r_refdef.frame.forward) < minparticledist)) {
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
at = (byte *) &d_8to24table[(byte) p->icolor];
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
VA[0].color[0] = at[0];
VA[0].color[1] = at[1];
VA[0].color[2] = at[2];
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
VA[0].color[3] = p->alpha * 255;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
memcpy (VA[1].color, VA[0].color, sizeof (VA[0].color));
memcpy (VA[2].color, VA[0].color, sizeof (VA[0].color));
memcpy (VA[3].color, VA[0].color, sizeof (VA[0].color));
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
switch (p->tex) {
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
case part_tex_dot:
VA[0].texcoord[0] = 0.0;
VA[0].texcoord[1] = 0.0;
VA[1].texcoord[0] = 0.5;
VA[1].texcoord[1] = 0.0;
VA[2].texcoord[0] = 0.5;
VA[2].texcoord[1] = 0.5;
VA[3].texcoord[0] = 0.0;
VA[3].texcoord[1] = 0.5;
break;
case part_tex_spark:
VA[0].texcoord[0] = 0.5;
VA[0].texcoord[1] = 0.0;
VA[1].texcoord[0] = 1.0;
VA[1].texcoord[1] = 0.0;
VA[2].texcoord[0] = 1.0;
VA[2].texcoord[1] = 0.5;
VA[3].texcoord[0] = 0.5;
VA[3].texcoord[1] = 0.5;
break;
case part_tex_smoke:
VA[0].texcoord[0] = 0.0;
VA[0].texcoord[1] = 0.5;
VA[1].texcoord[0] = 0.5;
VA[1].texcoord[1] = 0.5;
VA[2].texcoord[0] = 0.5;
VA[2].texcoord[1] = 1.0;
VA[3].texcoord[0] = 0.0;
VA[3].texcoord[1] = 1.0;
break;
}
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
scale = p->scale;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
VectorScale (r_refdef.frame.up, scale, up_scale);
VectorScale (r_refdef.frame.right, scale, right_scale);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
VectorAdd (right_scale, up_scale, up_right_scale);
VectorSubtract (right_scale, up_scale, down_right_scale);
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
VectorAdd (p->pos, down_right_scale, VA[0].vertex);
VectorSubtract (p->pos, up_right_scale, VA[1].vertex);
VectorSubtract (p->pos, down_right_scale, VA[2].vertex);
VectorAdd (p->pos, up_right_scale, VA[3].vertex);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
VA += 4;
Draw ALL of the particles, not just 2/3 of them. Using quads requires 4 elements, but triangles require 6. I'd gotten the element array setup right, but I'd forgotten to tweak vacount when drawing the particles.
2012-01-21 11:16:18 +00:00
vacount += 6;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
}
}
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (quake_part.vertex.location, 3, GL_FLOAT,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
0, sizeof (partvert_t),
&particleVertexArray[0].vertex);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (quake_part.color.location, 4, GL_UNSIGNED_BYTE,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
1, sizeof (partvert_t),
&particleVertexArray[0].color);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (quake_part.st.location, 2, GL_FLOAT,
Implement QF style particles. Actually looks pretty good against the sw style world.
2012-01-21 10:51:18 +00:00
0, sizeof (partvert_t),
&particleVertexArray[0].texcoord);
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, vacount, GL_UNSIGNED_SHORT, pVAindices);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDepthMask (GL_TRUE);
qfeglDisableVertexAttribArray (quake_part.vertex.location);
qfeglDisableVertexAttribArray (quake_part.color.location);
qfeglDisableVertexAttribArray (quake_part.st.location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
Split out the particle code.
2011-12-25 22:50:05 +00:00
}
static void
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
draw_id_particles (psystem_t *psystem)
Split out the particle code.
2011-12-25 22:50:05 +00:00
{
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
int vacount;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
float minparticledist;
partvert_t *VA;
[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 vp_mat;
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;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +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
mmulf (vp_mat, glsl_projection, glsl_view);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
// LordHavoc: particles should not affect zbuffer
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDepthMask (GL_FALSE);
qfeglUseProgram (quake_point.program);
qfeglEnableVertexAttribArray (quake_point.vertex.location);
qfeglEnableVertexAttribArray (quake_point.color.location);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +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
qfeglUniformMatrix4fv (quake_point.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*)&vp_mat[0]);//FIXME
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +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_point.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_point.palette.location, 0);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglEnable (GL_TEXTURE_2D);
qfeglBindTexture (GL_TEXTURE_2D, glsl_palette);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
minparticledist = DotProduct (r_refdef.frame.position,
[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
r_refdef.frame.forward)
+ r_particles_nearclip;
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
vacount = 0;
VA = particleVertexArray;
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
for (unsigned i = 0; i < psystem->numparticles; i++) {
particle_t *p = &psystem->particles[i];
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
// Don't render particles too close to us.
// Note, we must still do physics and such on them.
[renderer] Clean up use of vup/vright/vpn This moves the common camera setup code out of the individual drivers, and completely removes vup/vright/vpn from the non-software renderers. This has highlighted the craziness around AngleVectors with it putting +X forward, -Y right and +Z up. The main issue with this is it requires a 90 degree pre-rotation about the Z axis to get the camera pointing in the right direction, and that's for the native sw renderer (vulkan needs a 90 degree pre-rotation about X, and gl and glsl need to invert an axis, too), though at least it's just a matrix swizzle and vector negation. However, it does mean the camera matrices can't be used directly. Also rename vpn to vfwd (still abbreviated, but fwd is much clearer in meaning (to me, at least) than pn (plane normal, I guess, but which way?)).
2022-03-14 00:34:24 +00:00
if (!(DotProduct (p->pos, r_refdef.frame.forward) < minparticledist)) {
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
VA[0].color[0] = (byte) p->icolor;
VectorCopy (p->pos, VA[0].vertex);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
VA++;
vacount++;
}
}
[renderer] Move particles over to simd This has the advantage of getting entity_t out of the particle system, and much easier to read math. Also, it served as a nice test for my particle physics shaders (implemented the ideas in C). There's a lot of code that needs merging down: all but the actual drawing can be merged. There's some weirdness with color ramps, but I'll look into that later.
2021-12-18 16:21:39 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (quake_point.vertex.location, 3, GL_FLOAT,
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
0, sizeof (partvert_t),
&particleVertexArray[0].vertex);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglVertexAttribPointer (quake_point.color.location, 1, GL_UNSIGNED_BYTE,
Use the correct type for particle colors. Sending byte data as floats doesn't work too well :P Fixes the colors of the particles, but not the size :(.
2012-01-21 07:16:48 +00:00
1, sizeof (partvert_t),
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
&particleVertexArray[0].color);
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDrawArrays (GL_POINTS, 0, vacount);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
Rename the glsl qfgl functions to qfegl. Keep them separate from the gl renderer :)
2012-02-22 07:48:57 +00:00
qfeglDepthMask (GL_TRUE);
qfeglDisableVertexAttribArray (quake_point.vertex.location);
qfeglDisableVertexAttribArray (quake_point.color.location);
qfeglActiveTexture (GL_TEXTURE0 + 0);
qfeglDisable (GL_TEXTURE_2D);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
}
void
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
glsl_R_DrawParticles (psystem_t *psystem)
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
{
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
if (!psystem->numparticles) {
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
return;
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
}
if (!psystem->points_only) {
draw_qf_particles (psystem);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
} else {
[renderer] Move most of the scene rendering into r_screen r_screen isn't really the right place, but it gets the scene rendering out of the low-level renderers and will make it easier to sort out later, and hopefully easier to figure out a good design for vulkan.
2022-03-17 08:50:38 +00:00
draw_id_particles (psystem);
Implement particles as points. Unfortunately, the maximum point size on Intel hardwar seems to be 1, so I can't tell if the colors are right. This is largely just a hacked version of GL's particle code.
2012-01-19 01:38:05 +00:00
}
}
[particles] Create a psystem object This takes care of the global variables to a point (there is still the global struct shared between the non-vulkan renderers), but it also takes care of glsl's points-only rendering.
2021-12-19 05:47:25 +00:00
psystem_t * __attribute__((const))//FIXME
glsl_ParticleSystem (void)
{
return &r_psystem;
}
Reference in a new issue Copy permalink