qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-02-24 20:51:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/mod_internal.h

150 lines
5.3 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);
[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);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
void Skin_SetColormap (byte *dest, int top, int bottom);
void Skin_SetPalette (byte *dest, int top, int bottom);
typedef struct tex_s tex_t;
typedef struct colormap_s colormap_t;
tex_t *Skin_DupTex (const tex_t *tex);
typedef struct skin_s {
tex_t *tex;
uint32_t id;
} skin_t;
[skin] Implement top/bottom colors for gl They don't work yet if the entity does not have an external skin.
2024-01-15 01:28:02 +00:00
typedef struct glskin_s {
uint32_t id;
uint32_t fb;
} glskin_t;
[skin] Fix up dynamic library issues And further clean up skin api. It turns out that skin functions must all be in the render libs, and this results in Skin_Set (was Skin_SetSkin) needs to be accessed via a function pointer rather than directly :(
2024-01-15 06:26:09 +00:00
void Skin_Init (void);
uint32_t Skin_Set (const char *skinname);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
skin_t *Skin_Get (uint32_t skin) __attribute__((pure));
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
[skin] Fix up dynamic library issues And further clean up skin api. It turns out that skin functions must all be in the render libs, and this results in Skin_Set (was Skin_SetSkin) needs to be accessed via a function pointer rather than directly :(
2024-01-15 06:26:09 +00:00
void sw_Skin_SetupSkin (skin_t *skin);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
void sw_Skin_Destroy (skin_t *skin);
const byte *sw_Skin_Colormap (const colormap_t *colormap);
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
[skin] Fix up dynamic library issues And further clean up skin api. It turns out that skin functions must all be in the render libs, and this results in Skin_Set (was Skin_SetSkin) needs to be accessed via a function pointer rather than directly :(
2024-01-15 06:26:09 +00:00
void glsl_Skin_SetupSkin (skin_t *skin);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
void glsl_Skin_Destroy (skin_t *skin);
uint32_t glsl_Skin_Colormap (const colormap_t *colormap);
Fix skin functions for plugins.
2012-02-23 03:09:19 +00:00
[skin] Fix up dynamic library issues And further clean up skin api. It turns out that skin functions must all be in the render libs, and this results in Skin_Set (was Skin_SetSkin) needs to be accessed via a function pointer rather than directly :(
2024-01-15 06:26:09 +00:00
void gl_Skin_SetupSkin (skin_t *skin);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
void gl_Skin_Destroy (skin_t *skin);
[skin] Get team colors working for model skins This should actually get team colors working for all models, not just player.mdl.
2024-01-15 05:12:59 +00:00
glskin_t gl_Skin_Get (const tex_t *tex, const colormap_t *colormap,
const byte *texel_base);
[skin] Use an ECS registry to manage skins This takes care of the double free and also cleans up a lot of the skin api. However, the gl renderer lost top/bottom colors (for now). Vulkan skins still don't work yet.
2024-01-14 17:26:24 +00:00
Link the model libs to the render plugins.
2012-02-14 12:25:19 +00:00
#endif// __mod_internal_h
Reference in a new issue Copy permalink