qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quakeforge/include/mod_internal.h

135 lines
5.2 KiB
C
Raw Normal View History

Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
#ifndef __mod_internal_h
#define __mod_internal_h
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
#include "QF/darray.h"
Move IQM freeing into common code.
2012-05-16 09:09:44 +00:00
#include "QF/iqm.h"
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
#include "QF/model.h"
#include "QF/skin.h"
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
#include "QF/plugin/vid_render.h"
[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
typedef struct mod_alias_skin_s {
int skin_num;
int group_num; // -1 if not in an animated group
byte *texels;
maliasskindesc_t *skindesc;
} mod_alias_skin_t;
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
typedef struct stvertset_s DARRAY_TYPE (stvert_t) stvertset_t;
typedef struct mtriangleset_s DARRAY_TYPE (mtriangle_t) mtriangleset_t;
typedef struct trivertxset_s DARRAY_TYPE (trivertx_t *) trivertxset_t;
[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
typedef struct askinset_s DARRAY_TYPE (mod_alias_skin_t) askinset_t;
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
typedef struct mod_alias_ctx_s {
aliashdr_t *header;
model_t *mod;
stvertset_t stverts;
mtriangleset_t triangles;
trivertxset_t poseverts;
[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
askinset_t skins;
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
int aliasbboxmins[3];
int aliasbboxmaxs[3];
} mod_alias_ctx_t;
[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
typedef struct mod_sprite_ctx_s {
model_t *mod;
dsprite_t *dsprite;
msprite_t *sprite;
int numframes;
int *frame_numbers;
dspriteframe_t **dframes; ///< array of pointers to dframes (in)
mspriteframe_t ***frames; ///< array of pointers to mframe pointers (out)
} mod_sprite_ctx_t;
[model] Swap fullbright/top/bottom color func params This makes them semantically compatible with memcpy.
2021-12-07 03:51:33 +00:00
int Mod_CalcFullbright (byte *out, const byte *in, size_t pixels);
int Mod_ClearFullbright (byte *out, const byte *in, size_t pixels);
[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_FloodFillSkin (byte *skin, int skinwidth, int skinheight);
//FIXME gl specific. rewrite to use above
int Mod_Fullbright (byte * skin, int width, int height, const char *name);
void Mod_LoadBrushModel (model_t *mod, void *buffer);
void Mod_FindClipDepth (hull_t *hull);
model_t *Mod_FindName (const char *name);
float RadiusFromBounds (const vec3_t mins, const vec3_t maxs) __attribute__((pure));
[model] Load bsp textures into vulkan The textures for an entire model are loaded into a single memory object with shared between multiple images.
2021-01-19 09:15:05 +00:00
struct vulkan_ctx_s;
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
extern vid_model_funcs_t *m_funcs;
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void gl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m,
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
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 gl_Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx);
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void gl_Mod_FinalizeAliasModel (mod_alias_ctx_t *alias_ctx);
void gl_Mod_LoadExternalSkins (mod_alias_ctx_t *alias_ctx);
Finally, load textures for iqm :)
2012-05-14 14:02:06 +00:00
void gl_Mod_IQMFinish (model_t *mod);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void glsl_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *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 glsl_Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx);
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void glsl_Mod_FinalizeAliasModel (mod_alias_ctx_t *alias_ctx);
void glsl_Mod_LoadExternalSkins (mod_alias_ctx_t *alias_ctx);
Finally, load textures for iqm :)
2012-05-14 14:02:06 +00:00
void glsl_Mod_IQMFinish (model_t *mod);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[model] Clean up the globals for alias models
2021-02-01 12:11:45 +00:00
void sw_Mod_MakeAliasModelDisplayLists (mod_alias_ctx_t *alias_ctx, void *_m,
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
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 sw_Mod_LoadAllSkins (mod_alias_ctx_t *alias_ctx);
[sw] Free alias model cache memory when clearing models This fixes a Sys_Error when loading the level for the first demo (and probably many other times). It was mod_numknown getting set to 0 that triggered the issue, but that seems to be necessary for the other renderers. I think the whole model loading and caching system needs an overhaul as this doesn't feel quite right due to removing part of the advantage of caching the model data.
2023-03-20 08:45:28 +00:00
void sw_Mod_FinalizeAliasModel (mod_alias_ctx_t *alias_ctx);
Finally, load textures for iqm :)
2012-05-14 14:02:06 +00:00
void sw_Mod_IQMFinish (model_t *mod);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[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 gl_Mod_LoadLighting (model_t *mod, bsp_t *bsp);
void gl_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
struct texture_s;
void gl_Mod_ProcessTexture (model_t *mod, struct texture_s *tx);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[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 glsl_Mod_LoadLighting (model_t *mod, bsp_t *bsp);
[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 glsl_Mod_ProcessTexture (model_t *mod, struct texture_s *tx);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[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 sw_Mod_LoadLighting (model_t *mod, bsp_t *bsp);
Fix the alias model loader for plugins.
2012-02-23 03:55:50 +00:00
[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 Vulkan_Mod_LoadLighting (model_t *mod, bsp_t *bsp,
struct vulkan_ctx_s *ctx);
void Vulkan_Mod_SubdivideSurface (model_t *mod, msurface_t *fa,
struct vulkan_ctx_s *ctx);
[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 Vulkan_Mod_ProcessTexture (model_t *mod, struct texture_s *tx,
[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
struct vulkan_ctx_s *ctx);
[model] Load bsp textures into vulkan The textures for an entire model are loaded into a single memory object with shared between multiple images.
2021-01-19 09:15:05 +00:00
[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_LoadSpriteFrame (mspriteframe_t *frame, const dspriteframe_t *dframe);
void gl_Mod_SpriteLoadFrames (mod_sprite_ctx_t *sprite_ctx);
void glsl_Mod_SpriteLoadFrames (mod_sprite_ctx_t *sprite_ctx);
void sw_Mod_SpriteLoadFrames (mod_sprite_ctx_t *sprite_ctx);
Fix the sprite model loader for plugins.
2012-02-23 04:18:59 +00:00
Stub out the iqm loader.
2012-04-27 05:40:06 +00:00
void Mod_LoadIQM (model_t *mod, void *buffer);
Move IQM freeing into common code.
2012-05-16 09:09:44 +00:00
void Mod_FreeIQM (iqm_t *iqm);
Enable loading of iqm models in gl. They don't render yet, but the engine doesn't segfault. The vertex blend indices are rewritten with blend palette indices.
2012-05-17 06:55:38 +00:00
iqmblend_t *Mod_IQMBuildBlendPalette (iqm_t *iqm, int *size);
Massive whitespace cleanup. Lots of trailing whitespace and otherwise blank lines.
2012-05-21 23:23:22 +00:00
void Mod_LoadAliasModel (model_t *mod, void *buffer,
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
cache_allocator_t allocator);
void Mod_LoadSpriteModel (model_t *mod, void *buffer);
void Skin_Init (void);
[glsl] Fix a pile of memory leaks For the most part harmless, but fixing the leaks has been uncovering bugs.
2023-03-05 07:56:09 +00:00
void Skin_Shutdown (void);
[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 (skin_t *skin);
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
skin_t *Skin_SetColormap (skin_t *skin, int cmap);
skin_t *Skin_SetSkin (skin_t *skin, int cmap, const char *skinname);
void Skin_SetTranslation (int cmap, int top, int bottom);
[vulkan] Move both alias color maps into the one layer This cuts down on the memory requirements for skins by 25%, and simplifies the shader a bit more, too. While at it, I made alias skins nominally compatible with bsp textures: layer 0 is color, 1 is emissive, and 2 is the color map (emissive was on 3).
2022-11-15 04:09:41 +00:00
int Skin_CalcTopColors (byte *out, const byte *in, size_t pixels, int stride);
int Skin_CalcTopMask (byte *out, const byte *in, size_t pixels, int stride);
int Skin_CalcBottomColors(byte *out, const byte *in, size_t pixels, int stride);
int Skin_CalcBottomMask (byte *out, const byte *in, size_t pixels, int stride);
[model] Swap fullbright/top/bottom color func params This makes them semantically compatible with memcpy.
2021-12-07 03:51:33 +00:00
int Skin_ClearTopColors (byte *out, const byte *in, size_t pixels);
int Skin_ClearBottomColors (byte *out, const byte *in, size_t pixels);
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
void sw_Skin_SetupSkin (skin_t *skin, int cmap);
void sw_Skin_ProcessTranslation (int cmap, const byte *translation);
void sw_Skin_InitTranslations (void);
void glsl_Skin_SetupSkin (skin_t *skin, int cmap);
void glsl_Skin_ProcessTranslation (int cmap, const byte *translation);
void glsl_Skin_InitTranslations (void);
void gl_Skin_SetupSkin (skin_t *skin, int cmap);
void gl_Skin_ProcessTranslation (int cmap, const byte *translation);
void gl_Skin_InitTranslations (void);
[gl] Use glGenTextures to allocate texture numbers While the scheme of using our own allocated did work just fine, fisheye rendering uses glGenTextures which caused a texture id clash and thus invalid operations (the cube map texture happened to be the same as the console background texture). Sure, I could have just "fixed" the fisheye init code, but this brings gl closer in line with glsl (which makes extensive use of glGenTextures and glDeleteTextures). This doesn't fix any texture leaks gl has (plenty, I imagine), but it's a step in the right direction.
2022-03-15 04:29:05 +00:00
void gl_Skin_Init_Textures (void);
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
void gl_Skin_SetPlayerSkin (int width, int height, const byte *data);
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
#endif// __mod_internal_h