qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-24 05:11:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/QF/plugin/vid_render.h

166 lines
5.7 KiB
C
Raw Normal View History

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
/*
QF/plugin/vid_render.h
Video Renderer plugin data types
Copyright (C) 2001 Jeff Teunissen <deek@quakeforge.net>
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
*/
[plugin] Clean up the rest of the plugin structs
2021-06-22 10:47:20 +00:00
#ifndef __QF_plugin_vid_render_h
#define __QF_plugin_vid_render_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 <QF/draw.h>
#include <QF/plugin.h>
#include <QF/qtypes.h>
#include <QF/render.h>
#include <QF/screen.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/entity.h"//FIXME
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
struct plitem_s;
struct cvar_s;
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
struct scene_s;
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
struct skin_s;
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
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
struct mod_alias_ctx_s;
[sprite] Separate model and texture loading As much as it can be since the texture data is interleaved with the model data in the files (I guess not that bad a design for 25 years ago with the tight memory constraints), but this paves the way for supporting sprites in Vulkan.
2021-12-13 23:36:19 +00:00
struct mod_sprite_ctx_s;
[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
struct entqueue_s;
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
struct framebuffer_s;
[renderer] Clean up post processing While it's not where I want it to be, it at least now no longer messes with frame buffer binding or the view ports. This involved switching around buffers in D_WarpScreen so that the main buffer could be bound before post-processing.
2022-03-25 15:29:34 +00:00
struct vrect_s;
[renderer] Clean up some unwanted dependencies Nothing outside of the renderer should be including d_iface.h (locs.c does still for particle defines), and plugin/vid_render.h is more independent.
2022-05-26 05:41:08 +00:00
struct texture_s;
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +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
/*
All video plugins must export these functions
*/
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
typedef struct vid_model_funcs_s {
[model] Isolate renderer specific texture data This cleans up texture_t and possibly even improves locality of reference when running through texture chains (not profiled, and not actually the goal).
2021-01-19 04:05:39 +00:00
size_t texture_render_size;// size of renderer specific texture data
[model] Clean up the globals around model loading Covers only the generic load code (alias etc to follow), but this should take care of a lot of issues in the future.
2021-02-01 05:39:00 +00:00
void (*Mod_LoadLighting) (model_t *mod, bsp_t *bsp);
void (*Mod_SubdivideSurface) (model_t *mod, msurface_t *fa);
[renderer] Clean up some unwanted dependencies Nothing outside of the renderer should be including d_iface.h (locs.c does still for particle defines), and plugin/vid_render.h is more independent.
2022-05-26 05:41:08 +00:00
void (*Mod_ProcessTexture) (model_t *mod, struct texture_s *tx);
Stub out the iqm loader.
2012-04-27 05:40:06 +00:00
void (*Mod_LoadIQM) (model_t *mod, void *buffer);
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
void (*Mod_LoadAliasModel) (model_t *mod, void *buffer,
cache_allocator_t allocator);
void (*Mod_LoadSpriteModel) (model_t *mod, void *buffer);
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void (*Mod_MakeAliasModelDisplayLists) (struct mod_alias_ctx_s *alias_ctx,
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
void *_m, int _s, int extra);
[model] Make alias skin loading a batch operation Really, this won't make all that much difference because alias models with more than one skin are quite rare, and those with animated skin groups are even rarer. However, for those models that do have more than one skin, it will allow for reduced allocation overheads, and when supported (glsl, vulkan, maybe gl), loading all the skins into an array texture (since all skins are the same size, though external skins may vary), but that's not implemented yet, this just wraps the old one skin at a time code.
2022-04-04 06:38:27 +00:00
void (*Mod_LoadAllSkins) (struct mod_alias_ctx_s *alias_ctx);
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void (*Mod_FinalizeAliasModel) (struct mod_alias_ctx_s *alias_ctx);
void (*Mod_LoadExternalSkins) (struct mod_alias_ctx_s *alias_ctx);
Finally, load textures for iqm :)
2012-05-14 14:02:06 +00:00
void (*Mod_IQMFinish) (model_t *mod);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
int alias_cache;
[sprite] Separate model and texture loading As much as it can be since the texture data is interleaved with the model data in the files (I guess not that bad a design for 25 years ago with the tight memory constraints), but this paves the way for supporting sprites in Vulkan.
2021-12-13 23:36:19 +00:00
void (*Mod_SpriteLoadFrames) (struct mod_sprite_ctx_s *sprite_ctx);
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
[model] Support freeing of skin data I doubt it's enough, but it does seem to cover what's needed for glsl (maybe not the actual textures, unsure there, but I think they're recycled).
2022-05-12 13:46:31 +00:00
void (*Skin_Free) (struct skin_s *skin);
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
struct skin_s *(*Skin_SetColormap) (struct skin_s *skin, int cmap);
struct skin_s *(*Skin_SetSkin) (struct skin_s *skin, int cmap,
const char *skinname);
void (*Skin_SetupSkin) (struct skin_s *skin, int cmap);
void (*Skin_SetTranslation) (int cmap, int top, int bottom);
void (*Skin_ProcessTranslation) (int cmap, const byte *translation);
void (*Skin_InitTranslations) (void);
} vid_model_funcs_t;
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
struct tex_s;
[renderer] Add Draw_AddFont for registering a font It's implemented only in the Vulkan renderer, partly because there's a lot of experimenting going on with it, but the glyphs do get transferred to the GPU (checked in render doc). No rendering is done yet: still thinking about whether to do a quick-and-dirty test, or to add HarfBuzz immediately, and the design surrounding that.
2022-08-31 10:23:30 +00:00
struct rfont_s;
[renderer] Add a cell-based character buffer This is intended for the built-in 8x8 bitmap characters and quake's "conchars", but could potentially be used for any simple (non-composed characters) mono-spaced font. Currently, the buffers can be created, destroyed, cleared, scrolled vertically in either direction, and rendered to the screen in a single blast. One of the reasons for creating the buffer is to make it so scaling can be supported in the sw renderer.
2022-09-15 05:24:33 +00:00
struct draw_charbuffer_s;
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
typedef void (*capfunc_t) (struct tex_s *screencap, void *data);
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
typedef struct vid_render_funcs_s {
[util] Make PI_LoadPlugin always call general init function As the root cause for #16 was something else, this fixes only the basic cvar initialization, but does fix #19 (for now, at least).
2021-06-26 06:43:17 +00:00
void (*init) (void);
[renderer] Add a cell-based character buffer This is intended for the built-in 8x8 bitmap characters and quake's "conchars", but could potentially be used for any simple (non-composed characters) mono-spaced font. Currently, the buffers can be created, destroyed, cleared, scrolled vertically in either direction, and rendered to the screen in a single blast. One of the reasons for creating the buffer is to make it so scaling can be supported in the sw renderer.
2022-09-15 05:24:33 +00:00
void (*Draw_CharBuffer) (int x, int y, struct draw_charbuffer_s *buffer);
[console] Resurrect console scaling Currently only for gl/glsl/vulkan. However, rather than futzing with con_width and con_height (and trying to guess good values), con_scale (currently an integer) gives consistent pixel scaling regardless of window size.
2022-11-13 13:23:56 +00:00
void (*Draw_SetScale) (int scale);
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
void (*Draw_Character) (int x, int y, unsigned ch);
void (*Draw_String) (int x, int y, const char *str);
void (*Draw_nString) (int x, int y, const char *str, int count);
void (*Draw_AltString) (int x, int y, const char *str);
void (*Draw_ConsoleBackground) (int lines, byte alpha);
void (*Draw_Crosshair) (void);
void (*Draw_CrosshairAt) (int ch, int x, int y);
void (*Draw_TileClear) (int x, int y, int w, int h);
void (*Draw_Fill) (int x, int y, int w, int h, int c);
[render] Add basic 2d line drawing The software renderer uses Bresenham's line slice algorithm as presented by Michael Abrash in his Graphics Programming Black Book Special Edition with the serial numbers filed off (as such, more just so *I* can read the code easily), along with the Chen-Sutherland line clipping algorithm. The other renderers were more or less trivial in comparison.
2022-05-28 09:14:26 +00:00
void (*Draw_Line) (int x0, int y0, int x1, int y1, int c);
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
void (*Draw_TextBox) (int x, int y, int width, int lines, byte alpha);
void (*Draw_FadeScreen) (void);
void (*Draw_BlendScreen) (quat_t color);
qpic_t *(*Draw_CachePic) (const char *path, qboolean alpha);
void (*Draw_UncachePic) (const char *path);
qpic_t *(*Draw_MakePic) (int width, int height, const byte *data);
void (*Draw_DestroyPic) (qpic_t *pic);
qpic_t *(*Draw_PicFromWad) (const char *name);
void (*Draw_Pic) (int x, int y, qpic_t *pic);
void (*Draw_Picf) (float x, float y, qpic_t *pic);
void (*Draw_SubPic) (int x, int y, qpic_t *pic, int srcx, int srcy, int width, int height);
[renderer] Add fontid to Draw_AddFont and Draw_FontString It's not used yet, but the vulkan draw implementation will eventually support multiple fonts being loaded (and rendered at a time).
2022-10-02 23:58:27 +00:00
int (*Draw_AddFont) (struct rfont_s *font);
void (*Draw_FontString) (int x, int y, int fontid, const char *str);
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
[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
struct psystem_s *(*ParticleSystem) (void);
Separate render module loading from initialization. This allows the vid module to load the render module and access render specific functions before the renderer initializes, which happens to need an initialized vid module...
2012-04-10 04:27:53 +00:00
void (*R_Init) (void);
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
void (*R_ClearState) (void);
void (*R_LoadSkys) (const char *);
[renderer] Use scene_t to set the model data This replaces *_NewMap with *_NewScene and adds SCR_NewScene to handle loading a new map (for quake) in the renderer, and will eventually be how any new scene is loaded.
2022-05-05 05:41:46 +00:00
void (*R_NewScene) (struct scene_s *scene);
[qw] Clean up netgraph somewhat The renderer's LineGraph now takes a height parameter, and netgraph now uses cl_* cvars instead of r_* (which never really made sense), including it's own height cvar (the render graphs still use r_graphheight).
2021-07-11 01:59:27 +00:00
void (*R_LineGraph) (int x, int y, int *h_vals, int count, int height);
Ensure code paths stay within the one renderer. The gl renderer calling sw functions is bad news. Still all black, but I think that's because palette setting is disabled.
2012-04-11 13:45:23 +00:00
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
void (*begin_frame) (void);
void (*render_view) (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
void (*draw_particles) (struct psystem_s *psystem);
[renderer] Handle transparent surfaces Other than the view model (undecided on the approach) this has R_RenderView pretty much pulled out of the low level renderers. With this, I'll be able to focus on scene handling for a bit then getting shadows and fisheye working (again for fisheye).
2022-03-17 15:14:48 +00:00
void (*draw_transparent) (void);
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
void (*post_process) (struct framebuffer_s *src);
[renderer] Get timegraph and zgraph working Only for sw and gl right now, but this sorts out the issues that prevented the graphs working at all.
2022-03-15 06:42:43 +00:00
void (*set_2d) (int scaled);
[renderer] Move frame rendering out a layer. This is a step towards high-level unification of the renderers, as far as possible keeping only actual low-level implementation details in the individual renderers (some higher level stuff, eg shadows, is expected to be per-renderer as some things are just not feasible to implement in all renderers). However, the idea is to move the high-level functionality into scene rendering.
2022-03-07 14:32:44 +00:00
void (*end_frame) (void);
[renderer] Get sw fisheye working again Again, gl/vulkan not working yet (on the assumption that sw would be trickier). Fisheye overrides water warp because updating the projection map every frame is far too expensive. I've added a post-process pass to the interface in order to hide the implementation details, but I'm not sure I'm happy about how the multi-pass rendering for cube maps is handled (or having the frame buffers as exposed as they are), but mainly because Vulkan will make implementation interesting.
2022-03-24 06:45:01 +00:00
struct framebuffer_s *(*create_cube_map) (int side);
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
struct framebuffer_s *(*create_frame_buffer) (int width, int height);
[renderer] Add function to destroy frame buffers Needed for window resizing for fisheye and warp buffers (main buffers will be taken care of by the drivers).
2022-09-21 14:47:14 +00:00
void (*destroy_frame_buffer) (struct framebuffer_s *framebuffer);
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
void (*bind_framebuffer) (struct framebuffer_s *framebuffer);
[renderer] Clean up post processing While it's not where I want it to be, it at least now no longer messes with frame buffer binding or the view ports. This involved switching around buffers in D_WarpScreen so that the main buffer could be bound before post-processing.
2022-03-25 15:29:34 +00:00
void (*set_viewport) (const struct vrect_s *view);
[renderer] Clean up FOV and viewport handling Viewport and FOV updates are now separate so updating one doesn't cause recalculations of the other. Also, perspective setup is now done directly from the tangents of the half angles for fov_x and fov_y making the renderers independent of fov/aspect mode. I imagine things are a bit of a mess with view size changes, and especially screen size changes (not supported yet anyway), and vulkan winds up updating its projection matrices every frame, but everything that's expected to work does (vulkan errors out for fisheye or warp due to frame buffer creation not being supported yet).
2022-03-30 05:55:32 +00:00
// x and y are tan(f/2) for fov_x and fov_y
void (*set_fov) (float x, float y);
[renderer] Move to using dynamic frame buffers For now, OpenGL and Vulkan renderers are broken as I focused on getting the software renderer working (which was quite tricky to get right). This fixes a couple of issues: the segfault when warping the screen (due to the scene rendering move invalidating the warp buffer), and warp always having 320x200 resolution. There's still the problem of the effect being too subtle at high resolution, but that's just a matter of updating the tables and tweaking the code in D_WarpScreen. Another issue is the Draw functions should probably write directly to the main frame buffer or even one passed in as a parameter. This would remove the need for binding the main buffer at the beginning and end of the frame.
2022-03-24 03:22:27 +00:00
[renderer] Make screen capture support asynchronous operation This fixes (*ahem*) the vulkan renderer segfaulting when attempting to take a screenshot. However, the image is upside down. Also, remote snapshots and demo capture are broken for the moment.
2022-03-31 10:07:15 +00:00
void (*capture_screen) (capfunc_t callback, void *data);
Start working on creating the render plugins. Things blow up quite nicely. :)
2012-02-14 13:19:17 +00:00
vid_model_funcs_t *model_funcs;
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
} vid_render_funcs_t;
typedef struct vid_render_data_s {
viddef_t *vid;
refdef_t *refdef;
int scr_copytop;
int scr_copyeverything;
int scr_fullupdate; // set to 0 to force full redraw
[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
void (*viewsize_callback) (int view_size);
int *scr_viewsize;
int *graphheight;
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
float min_wateralpha;
qboolean force_fullscreen;
qboolean inhibit_viewmodel;
qboolean paused;
int lineadj;
[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
entity_t view_model; //FIXME still?!?
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
double frametime;
double realtime;
lightstyle_t *lightstyle;
} vid_render_data_t;
[plugin] Clean up the rest of the plugin structs
2021-06-22 10:47:20 +00:00
#endif // __QF_plugin_vid_render_h
Reference in a new issue Copy permalink