model_shared.h File Reference

#include <stddef.h>
#include "qdefs.h"
#include "bspfile.h"
#include "r_qshader.h"
#include "matrixlib.h"
#include "bih.h"
#include "model_brush.h"
#include "model_q1bsp.h"
#include "model_q2bsp.h"
#include "model_q3bsp.h"
#include "model_vbsp.h"
#include "model_sprite.h"
#include "model_alias.h"

Include dependency graph for model_shared.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	animscene_t
struct	blendweights_t
struct	mod_alloclightmap_row_t
struct	mod_alloclightmap_state_t
struct	model_t
struct	modloader_t
struct	msurface_lightmapinfo_t
struct	msurface_t
	describes the textures to use on a range of triangles in the model, and mins/maxs (AABB) for culling. More...
struct	mtexinfo_t
struct	r_meshbuffer_t
struct	shadowmesh_t
struct	shadowmeshvertexhash_t
struct	skinfile_t
struct	skinfileitem_t
struct	surfmesh_t
struct	texture_t
struct	texvecvertex_t

Macros
#define	SHADOWMESHVERTEXHASH   1024

Enumerations
enum	modtype_t {   mod_invalid , mod_brushq1 , mod_sprite , mod_alias ,   mod_brushq2 , mod_brushq3 , mod_brushhl2 , mod_obj ,   mod_null }
enum	synctype_t { ST_SYNC =0 , ST_RAND }

Functions
void	Mod_2PSB_Load (model_t *mod, void *buffer, void *bufferend)
int	Mod_Alias_GetExtendedTagInfoForIndex (const model_t *model, unsigned int skin, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
int	Mod_Alias_GetTagIndexForName (const model_t *model, unsigned int skin, const char *tagname)
int	Mod_Alias_GetTagMatrix (const model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, int tagindex, matrix4x4_t *outmatrix)
void	Mod_AliasInit (void)
qbool	Mod_AllocLightmap_Block (mod_alloclightmap_state_t *state, int blockwidth, int blockheight, int *outx, int *outy)
void	Mod_AllocLightmap_Free (mod_alloclightmap_state_t *state)
void	Mod_AllocLightmap_Init (mod_alloclightmap_state_t *state, struct mempool_s *mempool, int width, int height)
void	Mod_AllocLightmap_Reset (mod_alloclightmap_state_t *state)
void	Mod_AllocSurfMesh (struct mempool_s *mempool, int numvertices, int numtriangles, qbool lightmapoffsets, qbool vertexcolors)
void	Mod_BrushInit (void)
void	Mod_BSP2_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_BuildAliasSkinsFromSkinFiles (texture_t *skin, skinfile_t *skinfile, const char *meshname, const char *shadername)
void	Mod_BuildNormals (int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const int *elements, float *normal3f, qbool areaweighting)
void	Mod_BuildTextureVectorsFromNormals (int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const float *texcoord2f, const float *normal3f, const int *elements, float *svector3f, float *tvector3f, qbool areaweighting)
void	Mod_BuildVBOs (void)
int	Mod_BuildVertexRemapTableFromElements (int numelements, const int *elements, int numvertices, int *remapvertices)
void	Mod_ClearUsed (void)
int	Mod_CollisionBIH_PointSuperContents (struct model_s *model, int frame, const vec3_t point)
int	Mod_CollisionBIH_PointSuperContents_Mesh (struct model_s *model, int frame, const vec3_t point)
void	Mod_CollisionBIH_TraceBox (model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, struct trace_s *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
void	Mod_CollisionBIH_TraceBrush (model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, struct trace_s *trace, struct colbrushf_s *start, struct colbrushf_s *end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
void	Mod_CollisionBIH_TraceLine (model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, struct trace_s *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
qbool	Mod_CollisionBIH_TraceLineOfSight (struct model_s *model, const vec3_t start, const vec3_t end, const vec3_t acceptmins, const vec3_t acceptmaxs)
void	Mod_CollisionBIH_TracePoint (model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, struct trace_s *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
void	Mod_CollisionBIH_TracePoint_Mesh (model_t *model, const struct frameblend_s *frameblend, const struct skeleton_s *skeleton, struct trace_s *trace, const vec3_t start, int hitsupercontentsmask, int skipsupercontentsmask, int skipmaterialflagsmask)
int	Mod_CountSkinFiles (skinfile_t *skinfile)
void	Mod_CreateCollisionMesh (model_t *mod)
texture_shaderpass_t *	Mod_CreateShaderPass (struct mempool_s *mempool, struct skinframe_s *skinframe)
texture_shaderpass_t *	Mod_CreateShaderPassFromQ3ShaderLayer (struct mempool_s *mempool, const char *modelname, q3shaderinfo_layer_t *layer, int layerindex, int texflags, const char *texturename)
void	Mod_DARKPLACESMODEL_Load (model_t *mod, void *buffer, void *bufferend)
model_t *	Mod_FindName (const char *name, const char *parentname)
model_t *	Mod_ForName (const char *name, qbool crash, qbool checkdisk, const char *parentname)
void	Mod_FreeQ3Shaders (void)
void	Mod_FreeSkinFiles (skinfile_t *skinfile)
void	Mod_HLBSP_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IBSP_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IDP0_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IDP2_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IDP3_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IDS2_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_IDSP_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_Init (void)
void	Mod_INTERQUAKEMODEL_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_LoadCustomMaterial (struct mempool_s *mempool, texture_t *texture, const char *name, int supercontents, int materialflags, struct skinframe_s *skinframe)
	Sets up a material to render the provided skinframe. See also R_SkinFrame_LoadInternalBGRA.
model_t *	Mod_LoadModel (model_t *mod, qbool crash, qbool checkdisk)
void	Mod_LoadQ3Shaders (void)
skinfile_t *	Mod_LoadSkinFiles (void)
qbool	Mod_LoadTextureFromQ3Shader (struct mempool_s *mempool, const char *modelname, texture_t *texture, const char *name, qbool warnmissing, qbool fallback, int defaulttexflags, int defaultmaterialflags)
shader_t *	Mod_LookupQ3Shader (const char *name)
bih_t *	Mod_MakeCollisionBIH (model_t *model, qbool userendersurfaces, bih_t *out)
void	Mod_MakeSortedSurfaces (model_t *mod)
void	Mod_MAP_Load (model_t *mod, void *buffer, void *bufferend)
msurface_t *	Mod_Mesh_AddSurface (model_t *mod, texture_t *tex, qbool batchwithprevioussurface)
void	Mod_Mesh_AddTriangle (model_t *mod, msurface_t *surf, int e0, int e1, int e2)
void	Mod_Mesh_Create (model_t *mod, const char *name)
void	Mod_Mesh_Destroy (model_t *mod)
void	Mod_Mesh_Finalize (model_t *mod)
texture_t *	Mod_Mesh_GetTexture (model_t *mod, const char *name, int defaultdrawflags, int defaulttexflags, int defaultmaterialflags)
int	Mod_Mesh_IndexForVertex (model_t *mod, msurface_t *surf, float x, float y, float z, float nx, float ny, float nz, float s, float t, float u, float v, float r, float g, float b, float a)
void	Mod_Mesh_Reset (model_t *mod)
void	Mod_Mesh_Validate (model_t *mod)
void	Mod_OBJ_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_PSKMODEL_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_PurgeUnused (void)
void	Mod_Q1BSP_Load (model_t *mod, void *buffer, void *bufferend)
int	Mod_Q1BSP_NativeContentsFromSuperContents (int supercontents)
int	Mod_Q1BSP_SuperContentsFromNativeContents (int nativecontents)
int	Mod_Q2BSP_NativeContentsFromSuperContents (int supercontents)
int	Mod_Q2BSP_SuperContentsFromNativeContents (int nativecontents)
void	Mod_Reload (void)
int	Mod_RemoveDegenerateTriangles (int numtriangles, const int *inelement3i, int *outelement3i, const float *vertex3f)
void	Mod_RemoveStaleWorldModels (model_t *skip)
void	Mod_SetDrawSkyAndWater (model_t *mod)
	Sets the mod->DrawSky and mod->DrawAddWaterPlanes pointers conditionally based on whether surfaces in this submodel use these features called specifically by brush model loaders when generating submodels automatically called after model loader returns.
void	Mod_ShadowMesh_AddMesh (shadowmesh_t *mesh, const float *vertex3f, int numtris, const int *element3i)
int	Mod_ShadowMesh_AddVertex (shadowmesh_t *mesh, const float *vertex3f)
shadowmesh_t *	Mod_ShadowMesh_Alloc (struct mempool_s *mempool, int maxverts, int maxtriangles)
shadowmesh_t *	Mod_ShadowMesh_Begin (struct mempool_s *mempool, int maxverts, int maxtriangles)
void	Mod_ShadowMesh_CalcBBox (shadowmesh_t *firstmesh, vec3_t mins, vec3_t maxs, vec3_t center, float *radius)
shadowmesh_t *	Mod_ShadowMesh_Finish (shadowmesh_t *firstmesh, qbool createvbo)
void	Mod_ShadowMesh_Free (shadowmesh_t *mesh)
void	Mod_Skeletal_FreeBuffers (void)
void	Mod_SnapVertices (int numcomponents, int numvertices, float *vertices, float snap)
void	Mod_SpriteInit (void)
void	Mod_UnloadCustomMaterial (texture_t *texture, qbool purgeskins)
	Removes all shaderpasses from material, and optionally deletes the textures in the skinframes.
void	Mod_UnloadModel (model_t *mod)
qbool	Mod_ValidateElements (int *element3i, unsigned short *element3s, int numtriangles, int firstvertex, int numvertices, const char *filename, int fileline)
void	Mod_VBSP_Load (model_t *mod, void *buffer, void *bufferend)
void	Mod_VertexRangeFromElements (int numelements, const int *elements, int *firstvertexpointer, int *lastvertexpointer)
void	Mod_ZYMOTICMODEL_Load (model_t *mod, void *buffer, void *bufferend)
void	R_Mod_CompileShadowMap (struct entity_render_s *ent, vec3_t relativelightorigin, vec3_t relativelightdirection, float lightradius, int numsurfaces, const int *surfacelist)
void	R_Mod_Draw (struct entity_render_s *ent)
void	R_Mod_DrawAddWaterPlanes (struct entity_render_s *ent)
void	R_Mod_DrawDebug (struct entity_render_s *ent)
void	R_Mod_DrawDepth (struct entity_render_s *ent)
void	R_Mod_DrawLight (struct entity_render_s *ent, int numsurfaces, const int *surfacelist, const unsigned char *trispvs)
void	R_Mod_DrawPrepass (struct entity_render_s *ent)
void	R_Mod_DrawShadowMap (int side, struct entity_render_s *ent, const vec3_t relativelightorigin, const vec3_t relativelightdirection, float lightradius, int modelnumsurfaces, const int *modelsurfacelist, const unsigned char *surfacesides, const vec3_t lightmins, const vec3_t lightmaxs)
void	R_Mod_DrawSky (struct entity_render_s *ent)
void	R_Mod_GetLightInfo (struct entity_render_s *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outleaflist, unsigned char *outleafpvs, int *outnumleafspointer, int *outsurfacelist, unsigned char *outsurfacepvs, int *outnumsurfacespointer, unsigned char *outshadowtrispvs, unsigned char *outlighttrispvs, unsigned char *visitingleafpvs, int numfrustumplanes, const mplane_t *frustumplanes, qbool noocclusion)

Variables
model_t *	loadmodel
char	loadname [32]
unsigned char *	mod_base
struct cvar_s	mod_noshader_default_offsetmapping
struct cvar_s	mod_q3bsp_lightgrid_bsp_surfaces
struct cvar_s	mod_q3bsp_lightgrid_texture
struct cvar_s	mod_q3bsp_lightgrid_world_surfaces
struct cvar_s	mod_q3shader_default_offsetmapping
struct cvar_s	mod_q3shader_default_offsetmapping_bias
struct cvar_s	mod_q3shader_default_offsetmapping_scale
struct cvar_s	mod_q3shader_default_polygonfactor
struct cvar_s	mod_q3shader_default_polygonoffset
struct cvar_s	mod_q3shader_default_refractive_index
struct cvar_s	mod_q3shader_force_addalpha
struct cvar_s	mod_q3shader_force_terrain_alphaflag
struct cvar_s	r_fullbrights
struct cvar_s	r_mipnormalmaps
struct cvar_s	r_mipskins

Macro Definition Documentation

SHADOWMESHVERTEXHASH

#define SHADOWMESHVERTEXHASH   1024

Definition at line 152 of file model_shared.h.

Referenced by Mod_ShadowMesh_AddVertex(), and Mod_ShadowMesh_Alloc().

Enumeration Type Documentation

modtype_t

enum modtype_t

Enumerator
mod_invalid
mod_brushq1
mod_sprite
mod_alias
mod_brushq2
mod_brushq3
mod_brushhl2
mod_obj
mod_null

Definition at line 43 of file model_shared.h.

{mod_invalid, mod_brushq1, mod_sprite, mod_alias, mod_brushq2, mod_brushq3, mod_brushhl2, mod_obj, mod_null} modtype_t;

synctype_t

enum synctype_t

Enumerator
ST_SYNC
ST_RAND

Definition at line 34 of file model_shared.h.

{ST_SYNC=0, ST_RAND } synctype_t;

Function Documentation

Mod_2PSB_Load()

void Mod_2PSB_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 3881 of file model_brush.c.

{
    mod->brush.isbsp2 = true;
    mod->brush.isbsp2rmqe = true; // like bsp2 except leaf/node bounds are 16bit (unexpanded)
    mod->modeldatatypestring = "Q1BSP2rmqe";
    Mod_Q1BSP_Load(mod, buffer, bufferend);
}

References buffer, mod(), and Mod_Q1BSP_Load().

Mod_Alias_GetExtendedTagInfoForIndex()

int Mod_Alias_GetExtendedTagInfoForIndex	(	const model_t *	model,
		unsigned int	skin,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		int	tagindex,
		int *	parentindex,
		const char **	tagname,
		matrix4x4_t *	tag_localmatrix )

Mod_Alias_GetTagIndexForName()

int Mod_Alias_GetTagIndexForName	(	const model_t *	model,
		unsigned int	skin,
		const char *	tagname )

Definition at line 585 of file model_alias.c.

{
    int i;
    if(skin >= (unsigned int)model->numskins)
        skin = 0;
    if (model->num_bones)
        for (i = 0;i < model->num_bones;i++)
            if (!strcasecmp(tagname, model->data_bones[i].name))
                return i + 1;
    if (model->num_tags)
        for (i = 0;i < model->num_tags;i++)
            if (!strcasecmp(tagname, model->data_tags[i].name))
                return i + 1;
    return 0;
}

References i, model, and skin.

Referenced by CL_GetTagIndex(), SV_GetTagIndex(), VM_CL_setattachment(), VM_CL_skel_find_bone(), VM_SV_setattachment(), and VM_SV_skel_find_bone().

Mod_Alias_GetTagMatrix()

int Mod_Alias_GetTagMatrix	(	const model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		int	tagindex,
		matrix4x4_t *	outmatrix )

Mod_AliasInit()

void Mod_AliasInit

(

void

)

Definition at line 189 of file model_alias.c.

{
    int i;
    Cvar_RegisterVariable(&r_skeletal_debugbone);
    Cvar_RegisterVariable(&r_skeletal_debugbonecomponent);
    Cvar_RegisterVariable(&r_skeletal_debugbonevalue);
    Cvar_RegisterVariable(&r_skeletal_debugtranslatex);
    Cvar_RegisterVariable(&r_skeletal_debugtranslatey);
    Cvar_RegisterVariable(&r_skeletal_debugtranslatez);
    Cvar_RegisterVariable(&mod_alias_supporttagscale);
    Cvar_RegisterVariable(&mod_alias_force_animated);
    for (i = 0;i < 320;i++)
        mod_md3_sin[i] = sin(i * M_PI * 2.0f / 256.0);
#ifdef SSE_POSSIBLE
    if(Sys_HaveSSE())
    {
        Con_Printf("Skeletal animation uses SSE code path\n");
        r_skeletal_use_sse_defined = true;
        Cvar_RegisterVariable(&r_skeletal_use_sse);
    }
    else
        Con_Printf("Skeletal animation uses generic code path (SSE disabled or not detected)\n");
#else
    Con_Printf("Skeletal animation uses generic code path (SSE not compiled in)\n");
#endif
}

References Con_Printf(), Cvar_RegisterVariable(), i, M_PI, mod_alias_force_animated, mod_alias_supporttagscale, mod_md3_sin, r_skeletal_debugbone, r_skeletal_debugbonecomponent, r_skeletal_debugbonevalue, r_skeletal_debugtranslatex, r_skeletal_debugtranslatey, r_skeletal_debugtranslatez, sin(), and Sys_HaveSSE.

Referenced by Mod_Init().

Mod_AllocLightmap_Block()

qbool Mod_AllocLightmap_Block	(	mod_alloclightmap_state_t *	state,
		int	blockwidth,
		int	blockheight,
		int *	outx,
		int *	outy )

Definition at line 3482 of file model_shared.c.

{
    mod_alloclightmap_row_t *row;
    int y;
 
    row = state->rows + blockheight;
    if ((row->rowY < 0) || (row->currentX + blockwidth > state->width))
    {
        if (state->currentY + blockheight <= state->height)
        {
            // use the current allocation position
            row->rowY = state->currentY;
            row->currentX = 0;
            state->currentY += blockheight;
        }
        else
        {
            // find another position
            for (y = blockheight;y < state->height;y++)
            {
                if ((state->rows[y].rowY >= 0) && (state->rows[y].currentX + blockwidth <= state->width))
                {
                    row = state->rows + y;
                    break;
                }
            }
            if (y == state->height)
                return false;
        }
    }
    *outy = row->rowY;
    *outx = row->currentX;
    row->currentX += blockwidth;
 
    return true;
}

References mod_alloclightmap_row_t::currentX, mod_alloclightmap_state_t::currentY, height, mod_alloclightmap_state_t::height, mod_alloclightmap_state_t::rows, mod_alloclightmap_row_t::rowY, mod_alloclightmap_state_t::width, width, and y.

Referenced by Mod_GenerateLightmaps_CreateLightmaps(), Mod_Q1BSP_LoadFaces(), Mod_VBSP_LoadFaces(), and R_Shadow_PrepareLights().

Mod_AllocLightmap_Free()

void Mod_AllocLightmap_Free

(

mod_alloclightmap_state_t *

state

)

Definition at line 3475 of file model_shared.c.

{
    if (state->rows)
        Mem_Free(state->rows);
    memset(state, 0, sizeof(*state));
}

References Mem_Free, and mod_alloclightmap_state_t::rows.

Referenced by Mod_GenerateLightmaps_CreateLightmaps(), and R_Shadow_FreeShadowMaps().

Mod_AllocLightmap_Init()

void Mod_AllocLightmap_Init	(	mod_alloclightmap_state_t *	state,
		struct mempool_s *	mempool,
		int	width,
		int	height )

Mod_AllocLightmap_Reset()

void Mod_AllocLightmap_Reset

(

mod_alloclightmap_state_t *

state

)

Definition at line 3464 of file model_shared.c.

{
    int y;
    state->currentY = 0;
    for (y = 0;y < state->height;y++)
    {
        state->rows[y].currentX = 0;
        state->rows[y].rowY = -1;
    }
}

References mod_alloclightmap_row_t::currentX, mod_alloclightmap_state_t::currentY, mod_alloclightmap_state_t::height, mod_alloclightmap_state_t::rows, mod_alloclightmap_row_t::rowY, and y.

Referenced by Mod_GenerateLightmaps_CreateLightmaps(), Mod_Q1BSP_LoadFaces(), Mod_VBSP_LoadFaces(), and R_Shadow_PrepareLights().

Mod_AllocSurfMesh()

void Mod_AllocSurfMesh	(	struct mempool_s *	mempool,
		int	numvertices,
		int	numtriangles,
		qbool	lightmapoffsets,
		qbool	vertexcolors )

Mod_BrushInit()

void Mod_BrushInit

(

void

)

Definition at line 80 of file model_brush.c.

{
//  Cvar_RegisterVariable(&r_subdivide_size);
    Cvar_RegisterVariable(&mod_bsp_portalize);
    Cvar_RegisterVariable(&r_novis);
    Cvar_RegisterVariable(&r_nosurftextures);
    Cvar_RegisterVariable(&r_subdivisions_tolerance);
    Cvar_RegisterVariable(&r_subdivisions_mintess);
    Cvar_RegisterVariable(&r_subdivisions_maxtess);
    Cvar_RegisterVariable(&r_subdivisions_maxvertices);
    Cvar_RegisterVariable(&mod_q3bsp_curves_subdivisions_tolerance);
    Cvar_RegisterVariable(&mod_q3bsp_curves_subdivisions_mintess);
    Cvar_RegisterVariable(&mod_q3bsp_curves_subdivisions_maxtess);
    Cvar_RegisterVariable(&mod_q3bsp_curves_subdivisions_maxvertices);
    Cvar_RegisterVariable(&r_trippy);
    Cvar_RegisterVariable(&mod_noshader_default_offsetmapping);
    Cvar_RegisterVariable(&mod_obj_orientation);
    Cvar_RegisterVariable(&mod_q2bsp_littransparentsurfaces);
    Cvar_RegisterVariable(&mod_q3bsp_curves_collisions);
    Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
    Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
    Cvar_RegisterVariable(&mod_q3bsp_nolightmaps);
    Cvar_RegisterVariable(&mod_q3bsp_sRGBlightmaps);
    Cvar_RegisterVariable(&mod_q3bsp_lightgrid_texture);
    Cvar_RegisterVariable(&mod_q3bsp_lightgrid_world_surfaces);
    Cvar_RegisterVariable(&mod_q3bsp_lightgrid_bsp_surfaces);
    Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes);
    Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping);
    Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping_scale);
    Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping_bias);
    Cvar_RegisterVariable(&mod_q3shader_default_polygonfactor);
    Cvar_RegisterVariable(&mod_q3shader_default_polygonoffset);
    Cvar_RegisterVariable(&mod_q3shader_default_refractive_index);
    Cvar_RegisterVariable(&mod_q3shader_force_addalpha);
    Cvar_RegisterVariable(&mod_q3shader_force_terrain_alphaflag);
    Cvar_RegisterVariable(&mod_q1bsp_polygoncollisions);
    Cvar_RegisterVariable(&mod_q1bsp_traceoutofsolid);
    Cvar_RegisterVariable(&mod_q1bsp_zero_hullsize_cutoff);
    Cvar_RegisterVariable(&mod_recalculatenodeboxes);
 
    // these games were made for older DP engines and are no longer
    // maintained; use this hack to show their textures properly
    if(gamemode == GAME_NEXUIZ)
        Cvar_SetQuick(&mod_q3shader_force_addalpha, "1");
 
    memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
    dp_strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
    mod_q1bsp_texture_solid.surfaceflags = 0;
    mod_q1bsp_texture_solid.supercontents = SUPERCONTENTS_SOLID;
 
    mod_q1bsp_texture_sky = mod_q1bsp_texture_solid;
    dp_strlcpy(mod_q1bsp_texture_sky.name, "sky", sizeof(mod_q1bsp_texture_sky.name));
    mod_q1bsp_texture_sky.surfaceflags = Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT | Q3SURFACEFLAG_NOMARKS | Q3SURFACEFLAG_NODLIGHT | Q3SURFACEFLAG_NOLIGHTMAP;
    mod_q1bsp_texture_sky.supercontents = SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP;
 
    mod_q1bsp_texture_lava = mod_q1bsp_texture_solid;
    dp_strlcpy(mod_q1bsp_texture_lava.name, "*lava", sizeof(mod_q1bsp_texture_lava.name));
    mod_q1bsp_texture_lava.surfaceflags = Q3SURFACEFLAG_NOMARKS;
    mod_q1bsp_texture_lava.supercontents = SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
 
    mod_q1bsp_texture_slime = mod_q1bsp_texture_solid;
    dp_strlcpy(mod_q1bsp_texture_slime.name, "*slime", sizeof(mod_q1bsp_texture_slime.name));
    mod_q1bsp_texture_slime.surfaceflags = Q3SURFACEFLAG_NOMARKS;
    mod_q1bsp_texture_slime.supercontents = SUPERCONTENTS_SLIME;
 
    mod_q1bsp_texture_water = mod_q1bsp_texture_solid;
    dp_strlcpy(mod_q1bsp_texture_water.name, "*water", sizeof(mod_q1bsp_texture_water.name));
    mod_q1bsp_texture_water.surfaceflags = Q3SURFACEFLAG_NOMARKS;
    mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER;
}

References Cvar_RegisterVariable(), Cvar_SetQuick(), dp_strlcpy, GAME_NEXUIZ, gamemode, mod_bsp_portalize, mod_noshader_default_offsetmapping, mod_obj_orientation, mod_q1bsp_polygoncollisions, mod_q1bsp_texture_lava, mod_q1bsp_texture_sky, mod_q1bsp_texture_slime, mod_q1bsp_texture_solid, mod_q1bsp_texture_water, mod_q1bsp_traceoutofsolid, mod_q1bsp_zero_hullsize_cutoff, mod_q2bsp_littransparentsurfaces, mod_q3bsp_curves_collisions, mod_q3bsp_curves_subdivisions_maxtess, mod_q3bsp_curves_subdivisions_maxvertices, mod_q3bsp_curves_subdivisions_mintess, mod_q3bsp_curves_subdivisions_tolerance, mod_q3bsp_lightgrid_bsp_surfaces, mod_q3bsp_lightgrid_texture, mod_q3bsp_lightgrid_world_surfaces, mod_q3bsp_lightmapmergepower, mod_q3bsp_nolightmaps, mod_q3bsp_optimizedtraceline, mod_q3bsp_sRGBlightmaps, mod_q3bsp_tracelineofsight_brushes, mod_q3shader_default_offsetmapping, mod_q3shader_default_offsetmapping_bias, mod_q3shader_default_offsetmapping_scale, mod_q3shader_default_polygonfactor, mod_q3shader_default_polygonoffset, mod_q3shader_default_refractive_index, mod_q3shader_force_addalpha, mod_q3shader_force_terrain_alphaflag, mod_recalculatenodeboxes, texture_t::name, Q3SURFACEFLAG_NODLIGHT, Q3SURFACEFLAG_NOIMPACT, Q3SURFACEFLAG_NOLIGHTMAP, Q3SURFACEFLAG_NOMARKS, Q3SURFACEFLAG_SKY, r_nosurftextures, r_novis, r_subdivisions_maxtess, r_subdivisions_maxvertices, r_subdivisions_mintess, r_subdivisions_tolerance, r_trippy, texture_t::supercontents, SUPERCONTENTS_LAVA, SUPERCONTENTS_NODROP, SUPERCONTENTS_SKY, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, SUPERCONTENTS_WATER, and texture_t::surfaceflags.

Referenced by Mod_Init().

Mod_BSP2_Load()

void Mod_BSP2_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 3889 of file model_brush.c.

{
    mod->brush.isbsp2 = true;
    mod->modeldatatypestring = "Q1BSP2";
    Mod_Q1BSP_Load(mod, buffer, bufferend);
}

References buffer, mod(), and Mod_Q1BSP_Load().

Mod_BuildAliasSkinsFromSkinFiles()

void Mod_BuildAliasSkinsFromSkinFiles	(	texture_t *	skin,
		skinfile_t *	skinfile,
		const char *	meshname,
		const char *	shadername )

Definition at line 925 of file model_alias.c.

{
    int i;
    char stripbuf[MAX_QPATH];
    skinfileitem_t *skinfileitem;
    if(developer_extra.integer)
        Con_DPrintf("Looking up texture for %s (default: %s)\n", meshname, shadername);
    if (skinfile)
    {
        // the skin += loadmodel->num_surfaces part of this is because data_textures on alias models is arranged as [numskins][numsurfaces]
        for (i = 0;skinfile;skinfile = skinfile->next, i++, skin += loadmodel->num_surfaces)
        {
            memset(skin, 0, sizeof(*skin));
            // see if a mesh
            for (skinfileitem = skinfile->items;skinfileitem;skinfileitem = skinfileitem->next)
            {
                // leave the skin unitialized (nodraw) if the replacement is "common/nodraw" or "textures/common/nodraw"
                if (!strcmp(skinfileitem->name, meshname))
                {
                    Image_StripImageExtension(skinfileitem->replacement, stripbuf, sizeof(stripbuf));
                    if(developer_extra.integer)
                        Con_DPrintf("--> got %s from skin file\n", stripbuf);
                    Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, skin, stripbuf, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL);
                    break;
                }
            }
            if (!skinfileitem)
            {
                // don't render unmentioned meshes
                Mod_LoadCustomMaterial(loadmodel->mempool, skin, meshname, SUPERCONTENTS_SOLID, MATERIALFLAG_WALL, R_SkinFrame_LoadMissing());
                if(developer_extra.integer)
                    Con_DPrintf("--> skipping\n");
                skin->basematerialflags = skin->currentmaterialflags = MATERIALFLAG_NOSHADOW | MATERIALFLAG_NODRAW;
            }
        }
    }
    else
    {
        if(developer_extra.integer)
            Con_DPrintf("--> using default\n");
        Image_StripImageExtension(shadername, stripbuf, sizeof(stripbuf));
        Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, skin, stripbuf, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL);
    }
}

References Con_DPrintf(), developer_extra, i, Image_StripImageExtension(), cvar_t::integer, skinfile_t::items, loadmodel, MATERIALFLAG_NODRAW, MATERIALFLAG_NOSHADOW, MATERIALFLAG_WALL, MAX_QPATH, model_t::mempool, Mod_LoadCustomMaterial(), Mod_LoadTextureFromQ3Shader(), model_t::name, skinfileitem_t::name, skinfile_t::next, skinfileitem_t::next, model_t::num_surfaces, r_mipskins, R_SkinFrame_LoadMissing(), skinfileitem_t::replacement, skin, SUPERCONTENTS_SOLID, TEXF_ALPHA, TEXF_COMPRESS, TEXF_MIPMAP, and TEXF_PICMIP.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_BuildNormals()

void Mod_BuildNormals	(	int	firstvertex,
		int	numvertices,
		int	numtriangles,
		const float *	vertex3f,
		const int *	elements,
		float *	normal3f,
		qbool	areaweighting )

Definition at line 806 of file model_shared.c.

{
    int i, j;
    const int *element;
    float *vectorNormal;
    float areaNormal[3];
    // clear the vectors
    memset(normal3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
    // process each vertex of each triangle and accumulate the results
    // use area-averaging, to make triangles with a big area have a bigger
    // weighting on the vertex normal than triangles with a small area
    // to do so, just add the 'normals' together (the bigger the area
    // the greater the length of the normal is
    element = elements;
    for (i = 0; i < numtriangles; i++, element += 3)
    {
        TriangleNormal(
            vertex3f + element[0] * 3,
            vertex3f + element[1] * 3,
            vertex3f + element[2] * 3,
            areaNormal
            );
 
        if (!areaweighting)
            VectorNormalize(areaNormal);
 
        for (j = 0;j < 3;j++)
        {
            vectorNormal = normal3f + element[j] * 3;
            vectorNormal[0] += areaNormal[0];
            vectorNormal[1] += areaNormal[1];
            vectorNormal[2] += areaNormal[2];
        }
    }
    // and just normalize the accumulated vertex normal in the end
    vectorNormal = normal3f + 3 * firstvertex;
    for (i = 0; i < numvertices; i++, vectorNormal += 3)
        VectorNormalize(vectorNormal);
}

References i, TriangleNormal, and VectorNormalize.

Referenced by Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadFaces(), Mod_VBSP_LoadFaces(), Mod_ZYMOTICMODEL_Load(), RSurf_ActiveCustomEntity(), RSurf_PrepareVerticesForBatch(), and VM_CL_R_PolygonEnd().

Mod_BuildTextureVectorsFromNormals()

void Mod_BuildTextureVectorsFromNormals	(	int	firstvertex,
		int	numvertices,
		int	numtriangles,
		const float *	vertex3f,
		const float *	texcoord2f,
		const float *	normal3f,
		const int *	elements,
		float *	svector3f,
		float *	tvector3f,
		qbool	areaweighting )

Definition at line 893 of file model_shared.c.

{
    int i, tnum;
    float sdir[3], tdir[3], normal[3], *svec, *tvec;
    const float *v0, *v1, *v2, *tc0, *tc1, *tc2, *n;
    float f, tangentcross[3], v10[3], v20[3], tc10[2], tc20[2];
    const int *e;
    // clear the vectors
    memset(svector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
    memset(tvector3f + 3 * firstvertex, 0, numvertices * sizeof(float[3]));
    // process each vertex of each triangle and accumulate the results
    for (tnum = 0, e = elements;tnum < numtriangles;tnum++, e += 3)
    {
        v0 = vertex3f + e[0] * 3;
        v1 = vertex3f + e[1] * 3;
        v2 = vertex3f + e[2] * 3;
        tc0 = texcoord2f + e[0] * 2;
        tc1 = texcoord2f + e[1] * 2;
        tc2 = texcoord2f + e[2] * 2;
 
        // 79 add/sub/negate/multiply (1 cycle), 1 compare (3 cycle?), total cycles not counting load/store/exchange roughly 82 cycles
        // 6 add, 28 subtract, 39 multiply, 1 compare, 50% chance of 6 negates
 
        // calculate the edge directions and surface normal
        // 6 multiply, 9 subtract
        VectorSubtract(v1, v0, v10);
        VectorSubtract(v2, v0, v20);
        normal[0] = v20[1] * v10[2] - v20[2] * v10[1];
        normal[1] = v20[2] * v10[0] - v20[0] * v10[2];
        normal[2] = v20[0] * v10[1] - v20[1] * v10[0];
 
        // calculate the tangents
        // 12 multiply, 10 subtract
        tc10[1] = tc1[1] - tc0[1];
        tc20[1] = tc2[1] - tc0[1];
        sdir[0] = tc10[1] * v20[0] - tc20[1] * v10[0];
        sdir[1] = tc10[1] * v20[1] - tc20[1] * v10[1];
        sdir[2] = tc10[1] * v20[2] - tc20[1] * v10[2];
        tc10[0] = tc1[0] - tc0[0];
        tc20[0] = tc2[0] - tc0[0];
        tdir[0] = tc10[0] * v20[0] - tc20[0] * v10[0];
        tdir[1] = tc10[0] * v20[1] - tc20[0] * v10[1];
        tdir[2] = tc10[0] * v20[2] - tc20[0] * v10[2];
 
        // if texture is mapped the wrong way (counterclockwise), the tangents
        // have to be flipped, this is detected by calculating a normal from the
        // two tangents, and seeing if it is opposite the surface normal
        // 9 multiply, 2 add, 3 subtract, 1 compare, 50% chance of: 6 negates
        CrossProduct(tdir, sdir, tangentcross);
        if (DotProduct(tangentcross, normal) < 0)
        {
            VectorNegate(sdir, sdir);
            VectorNegate(tdir, tdir);
        }
 
        if (!areaweighting)
        {
            VectorNormalize(sdir);
            VectorNormalize(tdir);
        }
        for (i = 0;i < 3;i++)
        {
            VectorAdd(svector3f + e[i]*3, sdir, svector3f + e[i]*3);
            VectorAdd(tvector3f + e[i]*3, tdir, tvector3f + e[i]*3);
        }
    }
    // make the tangents completely perpendicular to the surface normal, and
    // then normalize them
    // 16 assignments, 2 divide, 2 sqrt, 2 negates, 14 adds, 24 multiplies
    for (i = 0, svec = svector3f + 3 * firstvertex, tvec = tvector3f + 3 * firstvertex, n = normal3f + 3 * firstvertex;i < numvertices;i++, svec += 3, tvec += 3, n += 3)
    {
        f = -DotProduct(svec, n);
        VectorMA(svec, f, n, svec);
        VectorNormalize(svec);
        f = -DotProduct(tvec, n);
        VectorMA(tvec, f, n, tvec);
        VectorNormalize(tvec);
    }
}

References CrossProduct, DotProduct, f, i, n, normal, v0, v1, v2, VectorAdd, VectorMA, VectorNegate, VectorNormalize, and VectorSubtract.

Referenced by Mod_Alias_MorphMesh_CompileFrames(), Mod_DARKPLACESMODEL_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_Mesh_Finalize(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_LoadFaces(), Mod_Q3BSP_LoadFaces(), Mod_VBSP_LoadFaces(), Mod_ZYMOTICMODEL_Load(), RSurf_ActiveCustomEntity(), and RSurf_PrepareVerticesForBatch().

Mod_BuildVBOs()

void Mod_BuildVBOs

(

void

)

Definition at line 2964 of file model_shared.c.

{
    if(cls.state == ca_dedicated)
        return;
 
    if (!loadmodel->surfmesh.num_vertices)
        return;
 
    if (gl_paranoid.integer && loadmodel->surfmesh.data_element3s && loadmodel->surfmesh.data_element3i)
    {
        int i;
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
        {
            if (loadmodel->surfmesh.data_element3s[i] != loadmodel->surfmesh.data_element3i[i])
            {
                Con_Printf(CON_WARN "Mod_BuildVBOs: element %u is incorrect (%u should be %u)\n", i, loadmodel->surfmesh.data_element3s[i], loadmodel->surfmesh.data_element3i[i]);
                loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
            }
        }
    }
 
    // upload short indices as a buffer
    if (loadmodel->surfmesh.data_element3s && !loadmodel->surfmesh.data_element3s_indexbuffer)
        loadmodel->surfmesh.data_element3s_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles * sizeof(short[3]), loadmodel->name, true, false, false, true);
 
    // upload int indices as a buffer
    if (loadmodel->surfmesh.data_element3i && !loadmodel->surfmesh.data_element3i_indexbuffer && !loadmodel->surfmesh.data_element3s)
        loadmodel->surfmesh.data_element3i_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles * sizeof(int[3]), loadmodel->name, true, false, false, false);
 
    // only build a vbo if one has not already been created (this is important for brush models which load specially)
    // we put several vertex data streams in the same buffer
    if (!loadmodel->surfmesh.data_vertex3f_vertexbuffer)
    {
        int size;
        unsigned char *mem;
        size = 0;
        loadmodel->surfmesh.data_vertex3f_bufferoffset           = size;if (loadmodel->surfmesh.data_vertex3f          ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
        loadmodel->surfmesh.data_svector3f_bufferoffset          = size;if (loadmodel->surfmesh.data_svector3f         ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
        loadmodel->surfmesh.data_tvector3f_bufferoffset          = size;if (loadmodel->surfmesh.data_tvector3f         ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
        loadmodel->surfmesh.data_normal3f_bufferoffset           = size;if (loadmodel->surfmesh.data_normal3f          ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
        loadmodel->surfmesh.data_texcoordtexture2f_bufferoffset  = size;if (loadmodel->surfmesh.data_texcoordtexture2f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
        loadmodel->surfmesh.data_texcoordlightmap2f_bufferoffset = size;if (loadmodel->surfmesh.data_texcoordlightmap2f) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
        loadmodel->surfmesh.data_lightmapcolor4f_bufferoffset    = size;if (loadmodel->surfmesh.data_lightmapcolor4f   ) size += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
        loadmodel->surfmesh.data_skeletalindex4ub_bufferoffset   = size;if (loadmodel->surfmesh.data_skeletalindex4ub  ) size += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
        loadmodel->surfmesh.data_skeletalweight4ub_bufferoffset  = size;if (loadmodel->surfmesh.data_skeletalweight4ub ) size += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
        mem = (unsigned char *)Mem_Alloc(tempmempool, size);
        if (loadmodel->surfmesh.data_vertex3f          ) memcpy(mem + loadmodel->surfmesh.data_vertex3f_bufferoffset          , loadmodel->surfmesh.data_vertex3f          , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
        if (loadmodel->surfmesh.data_svector3f         ) memcpy(mem + loadmodel->surfmesh.data_svector3f_bufferoffset         , loadmodel->surfmesh.data_svector3f         , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
        if (loadmodel->surfmesh.data_tvector3f         ) memcpy(mem + loadmodel->surfmesh.data_tvector3f_bufferoffset         , loadmodel->surfmesh.data_tvector3f         , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
        if (loadmodel->surfmesh.data_normal3f          ) memcpy(mem + loadmodel->surfmesh.data_normal3f_bufferoffset          , loadmodel->surfmesh.data_normal3f          , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
        if (loadmodel->surfmesh.data_texcoordtexture2f ) memcpy(mem + loadmodel->surfmesh.data_texcoordtexture2f_bufferoffset , loadmodel->surfmesh.data_texcoordtexture2f , loadmodel->surfmesh.num_vertices * sizeof(float[2]));
        if (loadmodel->surfmesh.data_texcoordlightmap2f) memcpy(mem + loadmodel->surfmesh.data_texcoordlightmap2f_bufferoffset, loadmodel->surfmesh.data_texcoordlightmap2f, loadmodel->surfmesh.num_vertices * sizeof(float[2]));
        if (loadmodel->surfmesh.data_lightmapcolor4f   ) memcpy(mem + loadmodel->surfmesh.data_lightmapcolor4f_bufferoffset   , loadmodel->surfmesh.data_lightmapcolor4f   , loadmodel->surfmesh.num_vertices * sizeof(float[4]));
        if (loadmodel->surfmesh.data_skeletalindex4ub  ) memcpy(mem + loadmodel->surfmesh.data_skeletalindex4ub_bufferoffset  , loadmodel->surfmesh.data_skeletalindex4ub  , loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]));
        if (loadmodel->surfmesh.data_skeletalweight4ub ) memcpy(mem + loadmodel->surfmesh.data_skeletalweight4ub_bufferoffset , loadmodel->surfmesh.data_skeletalweight4ub , loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]));
        loadmodel->surfmesh.data_vertex3f_vertexbuffer = R_Mesh_CreateMeshBuffer(mem, size, loadmodel->name, false, false, false, false);
        loadmodel->surfmesh.data_svector3f_vertexbuffer = loadmodel->surfmesh.data_svector3f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_tvector3f_vertexbuffer = loadmodel->surfmesh.data_tvector3f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_normal3f_vertexbuffer = loadmodel->surfmesh.data_normal3f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_texcoordtexture2f_vertexbuffer = loadmodel->surfmesh.data_texcoordtexture2f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_texcoordlightmap2f_vertexbuffer = loadmodel->surfmesh.data_texcoordlightmap2f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_lightmapcolor4f_vertexbuffer = loadmodel->surfmesh.data_lightmapcolor4f ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_skeletalindex4ub_vertexbuffer = loadmodel->surfmesh.data_skeletalindex4ub ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        loadmodel->surfmesh.data_skeletalweight4ub_vertexbuffer = loadmodel->surfmesh.data_skeletalweight4ub ? loadmodel->surfmesh.data_vertex3f_vertexbuffer : NULL;
        Mem_Free(mem);
    }
}

References ca_dedicated, cls, Con_Printf(), CON_WARN, surfmesh_t::data_element3i, surfmesh_t::data_element3i_indexbuffer, surfmesh_t::data_element3s, surfmesh_t::data_element3s_indexbuffer, surfmesh_t::data_lightmapcolor4f, surfmesh_t::data_lightmapcolor4f_bufferoffset, surfmesh_t::data_lightmapcolor4f_vertexbuffer, surfmesh_t::data_normal3f, surfmesh_t::data_normal3f_bufferoffset, surfmesh_t::data_normal3f_vertexbuffer, surfmesh_t::data_skeletalindex4ub, surfmesh_t::data_skeletalindex4ub_bufferoffset, surfmesh_t::data_skeletalindex4ub_vertexbuffer, surfmesh_t::data_skeletalweight4ub, surfmesh_t::data_skeletalweight4ub_bufferoffset, surfmesh_t::data_skeletalweight4ub_vertexbuffer, surfmesh_t::data_svector3f, surfmesh_t::data_svector3f_bufferoffset, surfmesh_t::data_svector3f_vertexbuffer, surfmesh_t::data_texcoordlightmap2f, surfmesh_t::data_texcoordlightmap2f_bufferoffset, surfmesh_t::data_texcoordlightmap2f_vertexbuffer, surfmesh_t::data_texcoordtexture2f, surfmesh_t::data_texcoordtexture2f_bufferoffset, surfmesh_t::data_texcoordtexture2f_vertexbuffer, surfmesh_t::data_tvector3f, surfmesh_t::data_tvector3f_bufferoffset, surfmesh_t::data_tvector3f_vertexbuffer, surfmesh_t::data_vertex3f, surfmesh_t::data_vertex3f_bufferoffset, surfmesh_t::data_vertex3f_vertexbuffer, gl_paranoid, i, cvar_t::integer, loadmodel, Mem_Alloc, Mem_Free, model_t::name, NULL, surfmesh_t::num_triangles, surfmesh_t::num_vertices, R_Mesh_CreateMeshBuffer(), size, client_static_t::state, model_t::surfmesh, and tempmempool.

Referenced by Mod_LoadModel(), Mod_OBJ_Load(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), and Mod_Q3BSP_Load().

Mod_BuildVertexRemapTableFromElements()

int Mod_BuildVertexRemapTableFromElements	(	int	numelements,
		const int *	elements,
		int	numvertices,
		int *	remapvertices )

Definition at line 724 of file model_shared.c.

{
    int i, count;
    unsigned char *used;
    used = (unsigned char *)Mem_Alloc(tempmempool, numvertices);
    memset(used, 0, numvertices);
    for (i = 0;i < numelements;i++)
        used[elements[i]] = 1;
    for (i = 0, count = 0;i < numvertices;i++)
        remapvertices[i] = used[i] ? count++ : -1;
    Mem_Free(used);
    return count;
}

References count, i, Mem_Alloc, Mem_Free, and tempmempool.

Mod_ClearUsed()

void Mod_ClearUsed

(

void

)

Definition at line 564 of file model_shared.c.

{
    int i;
    int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
    model_t *mod;
    for (i = 0;i < nummodels;i++)
        if ((mod = (model_t*) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0])
            mod->used = false;
}

References i, int(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), mod(), and models.

Referenced by CL_ParseServerInfo(), QW_CL_RequestNextDownload(), and SV_SpawnServer().

Mod_CollisionBIH_PointSuperContents()

int Mod_CollisionBIH_PointSuperContents	(	struct model_s *	model,
		int	frame,
		const vec3_t	point )

Definition at line 7348 of file model_brush.c.

{
    trace_t trace;
    Mod_CollisionBIH_TracePoint(model, NULL, NULL, &trace, point, 0, 0, 0);
    return trace.startsupercontents;
}

References Mod_CollisionBIH_TracePoint(), model, NULL, and trace_t::startsupercontents.

Referenced by Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), and Mod_VBSP_Load().

Mod_CollisionBIH_PointSuperContents_Mesh()

int Mod_CollisionBIH_PointSuperContents_Mesh	(	struct model_s *	model,
		int	frame,
		const vec3_t	point )

Definition at line 7387 of file model_brush.c.

{
#if 0
    // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid
    trace_t trace;
    vec3_t end;
    VectorSet(end, start[0], start[1], model->normalmins[2]);
    memset(&trace, 0, sizeof(trace));
    trace.fraction = 1;
    trace.hitsupercontentsmask = hitsupercontentsmask;
    trace.skipsupercontentsmask = skipsupercontentsmask;
    trace.skipmaterialflagsmask = skipmaterialflagsmask;
    Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask, skipsupercontentsmask, skipmaterialflagsmask);
    return trace.hitsupercontents;
#else
    return 0;
#endif
}

References trace_t::fraction, trace_t::hitsupercontents, trace_t::hitsupercontentsmask, Mod_CollisionBIH_TraceLine(), model, trace_t::skipmaterialflagsmask, trace_t::skipsupercontentsmask, and VectorSet.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_CollisionBIH_TraceBox()

void Mod_CollisionBIH_TraceBox	(	model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		struct trace_s *	trace,
		const vec3_t	start,
		const vec3_t	boxmins,
		const vec3_t	boxmaxs,
		const vec3_t	end,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Mod_CollisionBIH_TraceBrush()

void Mod_CollisionBIH_TraceBrush	(	model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		struct trace_s *	trace,
		struct colbrushf_s *	start,
		struct colbrushf_s *	end,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Mod_CollisionBIH_TraceLine()

void Mod_CollisionBIH_TraceLine	(	model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		struct trace_s *	trace,
		const vec3_t	start,
		const vec3_t	end,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Mod_CollisionBIH_TraceLineOfSight()

qbool Mod_CollisionBIH_TraceLineOfSight	(	struct model_s *	model,
		const vec3_t	start,
		const vec3_t	end,
		const vec3_t	acceptmins,
		const vec3_t	acceptmaxs )

Definition at line 7355 of file model_brush.c.

{
    trace_t trace;
    Mod_CollisionBIH_TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK, 0, MATERIALFLAGMASK_TRANSLUCENT);
    return trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, acceptmins, acceptmaxs);
}

References BoxesOverlap, trace_t::endpos, trace_t::fraction, MATERIALFLAGMASK_TRANSLUCENT, Mod_CollisionBIH_TraceLine(), model, NULL, and SUPERCONTENTS_VISBLOCKERMASK.

Mod_CollisionBIH_TracePoint()

void Mod_CollisionBIH_TracePoint	(	model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		struct trace_s *	trace,
		const vec3_t	start,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Mod_CollisionBIH_TracePoint_Mesh()

void Mod_CollisionBIH_TracePoint_Mesh	(	model_t *	model,
		const struct frameblend_s *	frameblend,
		const struct skeleton_s *	skeleton,
		struct trace_s *	trace,
		const vec3_t	start,
		int	hitsupercontentsmask,
		int	skipsupercontentsmask,
		int	skipmaterialflagsmask )

Mod_CountSkinFiles()

int Mod_CountSkinFiles

(

skinfile_t *

skinfile

)

Definition at line 2826 of file model_shared.c.

{
    int i;
    for (i = 0;skinfile;skinfile = skinfile->next, i++);
    return i;
}

References i, and skinfile_t::next.

Mod_CreateCollisionMesh()

void Mod_CreateCollisionMesh

(

model_t *

mod

)

Definition at line 1196 of file model_shared.c.

{
    int k, numcollisionmeshtriangles;
    qbool usesinglecollisionmesh = false;
    const msurface_t *surface = NULL;
 
    mempool_t *mempool = mod->mempool;
    if (!mempool && mod->brush.parentmodel)
        mempool = mod->brush.parentmodel->mempool;
    // make a single combined collision mesh for physics engine use
    // TODO rewrite this to use the collision brushes as source, to fix issues with e.g. common/caulk which creates no drawsurface
    numcollisionmeshtriangles = 0;
    for (k = mod->submodelsurfaces_start;k < mod->submodelsurfaces_end;k++)
    {
        surface = mod->data_surfaces + k;
        if (!strcmp(surface->texture->name, "collision") || !strcmp(surface->texture->name, "collisionconvex")) // found collision mesh
        {
            usesinglecollisionmesh = true;
            numcollisionmeshtriangles = surface->num_triangles;
            break;
        }
        if (!(surface->texture->supercontents & SUPERCONTENTS_SOLID))
            continue;
        numcollisionmeshtriangles += surface->num_triangles;
    }
    mod->brush.collisionmesh = Mod_ShadowMesh_Begin(mempool, numcollisionmeshtriangles * 3, numcollisionmeshtriangles);
    if (usesinglecollisionmesh)
        Mod_ShadowMesh_AddMesh(mod->brush.collisionmesh, mod->surfmesh.data_vertex3f, surface->num_triangles, (mod->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
    else
    {
        for (k = mod->submodelsurfaces_start; k < mod->submodelsurfaces_end; k++)
        {
            surface = mod->data_surfaces + k;
            if (!(surface->texture->supercontents & SUPERCONTENTS_SOLID))
                continue;
            Mod_ShadowMesh_AddMesh(mod->brush.collisionmesh, mod->surfmesh.data_vertex3f, surface->num_triangles, (mod->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
        }
    }
    mod->brush.collisionmesh = Mod_ShadowMesh_Finish(mod->brush.collisionmesh, false);
}

References mod(), Mod_ShadowMesh_AddMesh(), Mod_ShadowMesh_Begin(), Mod_ShadowMesh_Finish(), texture_t::name, NULL, msurface_t::num_firsttriangle, msurface_t::num_triangles, texture_t::supercontents, SUPERCONTENTS_SOLID, and msurface_t::texture.

Mod_CreateShaderPass()

texture_shaderpass_t * Mod_CreateShaderPass	(	struct mempool_s *	mempool,
		struct skinframe_s *	skinframe )

Mod_CreateShaderPassFromQ3ShaderLayer()

texture_shaderpass_t * Mod_CreateShaderPassFromQ3ShaderLayer	(	struct mempool_s *	mempool,
		const char *	modelname,
		q3shaderinfo_layer_t *	layer,
		int	layerindex,
		int	texflags,
		const char *	texturename )

Mod_DARKPLACESMODEL_Load()

void Mod_DARKPLACESMODEL_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 2163 of file model_alias.c.

{
    dpmheader_t *pheader;
    dpmframe_t *frames;
    dpmbone_t *bone;
    dpmmesh_t *dpmmesh;
    unsigned char *pbase;
    int i, j, k, meshvertices, meshtriangles;
    skinfile_t *skinfiles;
    unsigned char *data;
    float *bonepose;
    float biggestorigin, tempvec[3], modelscale;
    float f;
    float *poses;
 
    pheader = (dpmheader_t *)buffer;
    pbase = (unsigned char *)buffer;
    if (memcmp(pheader->id, "DARKPLACESMODEL\0", 16))
        Host_Error ("Mod_DARKPLACESMODEL_Load: %s is not a darkplaces model", loadmodel->name);
    if (BigLong(pheader->type) != 2)
        Host_Error ("Mod_DARKPLACESMODEL_Load: only type 2 (hierarchical skeletal pose) models are currently supported (name = %s)", loadmodel->name);
 
    loadmodel->modeldatatypestring = "DPM";
 
    loadmodel->type = mod_alias;
    loadmodel->synctype = ST_RAND;
 
    // byteswap header
    pheader->type = BigLong(pheader->type);
    pheader->filesize = BigLong(pheader->filesize);
    pheader->mins[0] = BigFloat(pheader->mins[0]);
    pheader->mins[1] = BigFloat(pheader->mins[1]);
    pheader->mins[2] = BigFloat(pheader->mins[2]);
    pheader->maxs[0] = BigFloat(pheader->maxs[0]);
    pheader->maxs[1] = BigFloat(pheader->maxs[1]);
    pheader->maxs[2] = BigFloat(pheader->maxs[2]);
    pheader->yawradius = BigFloat(pheader->yawradius);
    pheader->allradius = BigFloat(pheader->allradius);
    pheader->num_bones = BigLong(pheader->num_bones);
    pheader->num_meshs = BigLong(pheader->num_meshs);
    pheader->num_frames = BigLong(pheader->num_frames);
    pheader->ofs_bones = BigLong(pheader->ofs_bones);
    pheader->ofs_meshs = BigLong(pheader->ofs_meshs);
    pheader->ofs_frames = BigLong(pheader->ofs_frames);
 
    if (pheader->num_bones < 1 || pheader->num_meshs < 1)
    {
        Con_Printf("%s has no geometry\n", loadmodel->name);
        return;
    }
    if (pheader->num_frames < 1)
    {
        Con_Printf("%s has no frames\n", loadmodel->name);
        return;
    }
 
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
 
    // model bbox
    // LadyHavoc: actually we blow this away later with Mod_Alias_CalculateBoundingBox()
    for (i = 0;i < 3;i++)
    {
        loadmodel->normalmins[i] = pheader->mins[i];
        loadmodel->normalmaxs[i] = pheader->maxs[i];
        loadmodel->yawmins[i] = i != 2 ? -pheader->yawradius : pheader->mins[i];
        loadmodel->yawmaxs[i] = i != 2 ? pheader->yawradius : pheader->maxs[i];
        loadmodel->rotatedmins[i] = -pheader->allradius;
        loadmodel->rotatedmaxs[i] = pheader->allradius;
    }
    loadmodel->radius = pheader->allradius;
    loadmodel->radius2 = pheader->allradius * pheader->allradius;
 
    // load external .skin files if present
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
 
    meshvertices = 0;
    meshtriangles = 0;
 
    // gather combined statistics from the meshes
    dpmmesh = (dpmmesh_t *) (pbase + pheader->ofs_meshs);
    for (i = 0;i < (int)pheader->num_meshs;i++)
    {
        int numverts = BigLong(dpmmesh->num_verts);
        meshvertices += numverts;
        meshtriangles += BigLong(dpmmesh->num_tris);
        dpmmesh++;
    }
 
    loadmodel->numframes = pheader->num_frames;
    loadmodel->num_bones = pheader->num_bones;
    loadmodel->num_poses = loadmodel->numframes;
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces = pheader->num_meshs;
    loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
    loadmodel->num_texturesperskin = loadmodel->num_surfaces;
    loadmodel->surfmesh.num_vertices = meshvertices;
    loadmodel->surfmesh.num_triangles = meshtriangles;
    loadmodel->surfmesh.num_blends = 0;
 
    // do most allocations as one merged chunk
    // This is only robust for C standard types!
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool,
        loadmodel->num_surfaces * sizeof(int)
        + meshtriangles * sizeof(int[3])
        + (meshvertices <= 65536 ? meshtriangles * sizeof(unsigned short[3]) : 0)
        + meshvertices * (sizeof(float[14]) + sizeof(unsigned short) + sizeof(unsigned char[2][4]))
        + loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7])
        + loadmodel->num_bones * sizeof(float[12]));
    // Pointers must be taken in descending order of alignment requirement!
    loadmodel->surfmesh.data_vertex3f                  = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_svector3f                 = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_tvector3f                 = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_normal3f                  = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_texcoordtexture2f         = (float *)data; data += meshvertices * sizeof(float[2]);
    loadmodel->data_baseboneposeinverse                = (float *)data; data += loadmodel->num_bones * sizeof(float[12]);
    loadmodel->modelsurfaces_sorted                      = (int *)data; data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->surfmesh.data_element3i                   = (int *)data; data += meshtriangles * sizeof(int[3]);
    loadmodel->surfmesh.blends                = (unsigned short *)data; data += meshvertices * sizeof(unsigned short);
    if (meshvertices <= 65536)
    {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data; data += meshtriangles * sizeof(unsigned short[3]);
    }
    loadmodel->data_poses7s                            = (short *)data; data += loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]);
    loadmodel->surfmesh.data_skeletalindex4ub  = (unsigned char *)data; data += meshvertices * sizeof(unsigned char[4]);
    loadmodel->surfmesh.data_skeletalweight4ub = (unsigned char *)data; data += meshvertices * sizeof(unsigned char[4]);
    // Struct alignment requirements could change so we can't assume them here
    // otherwise a safe-looking commit could introduce undefined behaviour!
    loadmodel->data_surfaces = Mem_AllocType(loadmodel->mempool, msurface_t, loadmodel->num_surfaces * sizeof(msurface_t));
    loadmodel->data_textures = Mem_AllocType(loadmodel->mempool, texture_t, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
    loadmodel->skinscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numskins * sizeof(animscene_t));
    loadmodel->data_bones = Mem_AllocType(loadmodel->mempool, aliasbone_t, loadmodel->num_bones * sizeof(aliasbone_t));
    loadmodel->animscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numframes * sizeof(animscene_t));
    loadmodel->surfmesh.data_blendweights = Mem_AllocType(loadmodel->mempool, blendweights_t, meshvertices * sizeof(blendweights_t));
 
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // load the bone info
    bone = (dpmbone_t *) (pbase + pheader->ofs_bones);
    for (i = 0;i < loadmodel->num_bones;i++)
    {
        memcpy(loadmodel->data_bones[i].name, bone[i].name, sizeof(bone[i].name));
        loadmodel->data_bones[i].flags = BigLong(bone[i].flags);
        loadmodel->data_bones[i].parent = BigLong(bone[i].parent);
        if (loadmodel->data_bones[i].parent >= i)
            Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
    }
 
    // load the frames
    frames = (dpmframe_t *) (pbase + pheader->ofs_frames);
    // figure out scale of model from root bone, for compatibility with old dpmodel versions
    poses = (float *) (pbase + BigLong(frames[0].ofs_bonepositions));
    tempvec[0] = BigFloat(poses[0]);
    tempvec[1] = BigFloat(poses[1]);
    tempvec[2] = BigFloat(poses[2]);
    modelscale = VectorLength(tempvec);
    biggestorigin = 0;
    for (i = 0;i < loadmodel->numframes;i++)
    {
        memcpy(loadmodel->animscenes[i].name, frames[i].name, sizeof(frames[i].name));
        loadmodel->animscenes[i].firstframe = i;
        loadmodel->animscenes[i].framecount = 1;
        loadmodel->animscenes[i].loop = true;
        loadmodel->animscenes[i].framerate = 10;
        // load the bone poses for this frame
        poses = (float *) (pbase + BigLong(frames[i].ofs_bonepositions));
        for (j = 0;j < loadmodel->num_bones*12;j++)
        {
            f = fabs(BigFloat(poses[j]));
            biggestorigin = max(biggestorigin, f);
        }
        // stuff not processed here: mins, maxs, yawradius, allradius
    }
    loadmodel->num_posescale = biggestorigin / 32767.0f;
    loadmodel->num_poseinvscale = 1.0f / loadmodel->num_posescale;
    for (i = 0;i < loadmodel->numframes;i++)
    {
        const float *frameposes = (float *) (pbase + BigLong(frames[i].ofs_bonepositions));
        for (j = 0;j < loadmodel->num_bones;j++)
        {
            float pose[12];
            matrix4x4_t posematrix;
            for (k = 0;k < 12;k++)
                pose[k] = BigFloat(frameposes[j*12+k]);
            // scale child bones to match the root scale
            if (loadmodel->data_bones[j].parent >= 0)
            {
                pose[3] *= modelscale;
                pose[7] *= modelscale;
                pose[11] *= modelscale;
            }
            // normalize rotation matrix
            VectorNormalize(pose + 0);
            VectorNormalize(pose + 4);
            VectorNormalize(pose + 8);
            Matrix4x4_FromArray12FloatD3D(&posematrix, pose);
            Matrix4x4_ToBonePose7s(&posematrix, loadmodel->num_poseinvscale, loadmodel->data_poses7s + 7*(i*loadmodel->num_bones+j));
        }
    }
 
    // load the meshes now
    dpmmesh = (dpmmesh_t *) (pbase + pheader->ofs_meshs);
    meshvertices = 0;
    meshtriangles = 0;
    // reconstruct frame 0 matrices to allow reconstruction of the base mesh
    // (converting from weight-blending skeletal animation to
    //  deformation-based skeletal animation)
    poses = (float *) (pbase + BigLong(frames[0].ofs_bonepositions));
    bonepose = (float *)Z_Malloc(loadmodel->num_bones * sizeof(float[12]));
    for (i = 0;i < loadmodel->num_bones;i++)
    {
        float m[12];
        for (k = 0;k < 12;k++)
            m[k] = BigFloat(poses[i*12+k]);
        if (loadmodel->data_bones[i].parent >= 0)
            R_ConcatTransforms(bonepose + 12 * loadmodel->data_bones[i].parent, m, bonepose + 12 * i);
        else
            for (k = 0;k < 12;k++)
                bonepose[12*i+k] = m[k];
    }
    for (i = 0;i < loadmodel->num_surfaces;i++, dpmmesh++)
    {
        const int *inelements;
        int *outelement3i;
        unsigned short *outelement3s;
        const float *intexcoord;
        msurface_t *surface;
 
        loadmodel->modelsurfaces_sorted[i] = i;
        surface = loadmodel->data_surfaces + i;
        surface->texture = loadmodel->data_textures + i;
        surface->num_firsttriangle = meshtriangles;
        surface->num_triangles = BigLong(dpmmesh->num_tris);
        surface->num_firstvertex = meshvertices;
        surface->num_vertices = BigLong(dpmmesh->num_verts);
        meshvertices += surface->num_vertices;
        meshtriangles += surface->num_triangles;
 
        inelements = (int *) (pbase + BigLong(dpmmesh->ofs_indices));
        outelement3i = loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3;
        outelement3s = loadmodel->surfmesh.data_element3s ? loadmodel->surfmesh.data_element3s + surface->num_firsttriangle * 3 : NULL;
        for (j = 0;j < surface->num_triangles;j++)
        {
            // swap element order to flip triangles, because Quake uses clockwise (rare) and dpm uses counterclockwise (standard)
            outelement3i[j * 3 + 0] = surface->num_firstvertex + BigLong(inelements[j * 3 + 2]);
            outelement3i[j * 3 + 1] = surface->num_firstvertex + BigLong(inelements[j * 3 + 1]);
            outelement3i[j * 3 + 2] = surface->num_firstvertex + BigLong(inelements[j * 3 + 0]);
            if (outelement3s)
            {
                outelement3s[j * 3 + 0] = outelement3i[j * 3 + 0];
                outelement3s[j * 3 + 1] = outelement3i[j * 3 + 1];
                outelement3s[j * 3 + 2] = outelement3i[j * 3 + 2];
            }
        }
 
        intexcoord = (float *) (pbase + BigLong(dpmmesh->ofs_texcoords));
        for (j = 0;j < surface->num_vertices*2;j++)
            loadmodel->surfmesh.data_texcoordtexture2f[j + surface->num_firstvertex * 2] = BigFloat(intexcoord[j]);
 
        data = (unsigned char *) (pbase + BigLong(dpmmesh->ofs_verts));
        for (j = surface->num_firstvertex;j < surface->num_firstvertex + surface->num_vertices;j++)
        {
            int weightindex[4] = { 0, 0, 0, 0 };
            float weightinfluence[4] = { 0, 0, 0, 0 };
            int l;
            int numweights = BigLong(((dpmvertex_t *)data)->numbones);
            data += sizeof(dpmvertex_t);
            for (k = 0;k < numweights;k++)
            {
                const dpmbonevert_t *vert = (dpmbonevert_t *) data;
                int boneindex = BigLong(vert->bonenum);
                const float *m = bonepose + 12 * boneindex;
                float influence = BigFloat(vert->influence);
                float relativeorigin[3], relativenormal[3];
                relativeorigin[0] = BigFloat(vert->origin[0]);
                relativeorigin[1] = BigFloat(vert->origin[1]);
                relativeorigin[2] = BigFloat(vert->origin[2]);
                relativenormal[0] = BigFloat(vert->normal[0]);
                relativenormal[1] = BigFloat(vert->normal[1]);
                relativenormal[2] = BigFloat(vert->normal[2]);
                // blend the vertex bone weights into the base mesh
                loadmodel->surfmesh.data_vertex3f[j*3+0] += relativeorigin[0] * m[0] + relativeorigin[1] * m[1] + relativeorigin[2] * m[ 2] + influence * m[ 3];
                loadmodel->surfmesh.data_vertex3f[j*3+1] += relativeorigin[0] * m[4] + relativeorigin[1] * m[5] + relativeorigin[2] * m[ 6] + influence * m[ 7];
                loadmodel->surfmesh.data_vertex3f[j*3+2] += relativeorigin[0] * m[8] + relativeorigin[1] * m[9] + relativeorigin[2] * m[10] + influence * m[11];
                loadmodel->surfmesh.data_normal3f[j*3+0] += relativenormal[0] * m[0] + relativenormal[1] * m[1] + relativenormal[2] * m[ 2];
                loadmodel->surfmesh.data_normal3f[j*3+1] += relativenormal[0] * m[4] + relativenormal[1] * m[5] + relativenormal[2] * m[ 6];
                loadmodel->surfmesh.data_normal3f[j*3+2] += relativenormal[0] * m[8] + relativenormal[1] * m[9] + relativenormal[2] * m[10];
                if (!k)
                {
                    // store the first (and often only) weight
                    weightinfluence[0] = influence;
                    weightindex[0] = boneindex;
                }
                else
                {
                    // sort the new weight into this vertex's weight table
                    // (which only accepts up to 4 bones per vertex)
                    for (l = 0;l < 4;l++)
                    {
                        if (weightinfluence[l] < influence)
                        {
                            // move weaker influence weights out of the way first
                            int l2;
                            for (l2 = 3;l2 > l;l2--)
                            {
                                weightinfluence[l2] = weightinfluence[l2-1];
                                weightindex[l2] = weightindex[l2-1];
                            }
                            // store the new weight
                            weightinfluence[l] = influence;
                            weightindex[l] = boneindex;
                            break;
                        }
                    }
                }
                data += sizeof(dpmbonevert_t);
            }
            loadmodel->surfmesh.blends[j] = Mod_Skeletal_CompressBlend(loadmodel, weightindex, weightinfluence);
            loadmodel->surfmesh.data_skeletalindex4ub[j*4  ] = weightindex[0];
            loadmodel->surfmesh.data_skeletalindex4ub[j*4+1] = weightindex[1];
            loadmodel->surfmesh.data_skeletalindex4ub[j*4+2] = weightindex[2];
            loadmodel->surfmesh.data_skeletalindex4ub[j*4+3] = weightindex[3];
            loadmodel->surfmesh.data_skeletalweight4ub[j*4  ] = (unsigned char)(weightinfluence[0]*255.0f);
            loadmodel->surfmesh.data_skeletalweight4ub[j*4+1] = (unsigned char)(weightinfluence[1]*255.0f);
            loadmodel->surfmesh.data_skeletalweight4ub[j*4+2] = (unsigned char)(weightinfluence[2]*255.0f);
            loadmodel->surfmesh.data_skeletalweight4ub[j*4+3] = (unsigned char)(weightinfluence[3]*255.0f);
        }
 
        // since dpm models do not have named sections, reuse their shader name as the section name
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + i, skinfiles, dpmmesh->shadername, dpmmesh->shadername);
 
        Mod_ValidateElements(loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3, loadmodel->surfmesh.data_element3s + surface->num_firsttriangle * 3, surface->num_triangles, surface->num_firstvertex, surface->num_vertices, __FILE__, __LINE__);
    }
    if (loadmodel->surfmesh.num_blends < meshvertices)
        loadmodel->surfmesh.data_blendweights = Mem_ReallocType(loadmodel->mempool, loadmodel->surfmesh.data_blendweights, blendweights_t, loadmodel->surfmesh.num_blends * sizeof(blendweights_t));
    Z_Free(bonepose);
    Mod_FreeSkinFiles(skinfiles);
    Mod_MakeSortedSurfaces(loadmodel);
 
    // compute all the mesh information that was not loaded from the file
    Mod_BuildBaseBonePoses();
    Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0);
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References dpmheader_t::allradius, model_t::AnimateVertices, model_t::animscenes, BigFloat, BigLong, surfmesh_t::blends, dpmbonevert_t::bonenum, buffer, model_t::collision_bih, model_t::CompileShadowMap, Con_Printf(), data, model_t::data_baseboneposeinverse, surfmesh_t::data_blendweights, model_t::data_bones, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_normal3f, model_t::data_poses7s, surfmesh_t::data_skeletalindex4ub, surfmesh_t::data_skeletalweight4ub, model_t::data_surfaces, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, f, fabs(), dpmheader_t::filesize, animscene_t::firstframe, aliasbone_t::flags, flags, animscene_t::framecount, animscene_t::framerate, Host_Error(), i, dpmheader_t::id, dpmbonevert_t::influence, int(), cvar_t::integer, surfmesh_t::isanimated, loadmodel, animscene_t::loop, Matrix4x4_FromArray12FloatD3D(), Matrix4x4_ToBonePose7s(), max, dpmheader_t::maxs, Mem_Alloc, Mem_AllocType, Mem_ReallocType, model_t::mempool, dpmheader_t::mins, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildBaseBonePoses(), Mod_BuildTextureVectorsFromNormals(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_Skeletal_AnimateVertices(), Mod_Skeletal_CompressBlend(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, aliasbone_t::name, animscene_t::name, dpmbone_t::name, dpmframe_t::name, model_t::name, dpmbonevert_t::normal, model_t::normalmaxs, model_t::normalmins, NULL, surfmesh_t::num_blends, dpmheader_t::num_bones, model_t::num_bones, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, dpmheader_t::num_frames, dpmheader_t::num_meshs, model_t::num_poseinvscale, model_t::num_poses, model_t::num_posescale, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, dpmmesh_t::num_tris, msurface_t::num_vertices, surfmesh_t::num_vertices, dpmmesh_t::num_verts, model_t::numframes, model_t::numskins, dpmheader_t::ofs_bones, dpmheader_t::ofs_frames, dpmmesh_t::ofs_indices, dpmheader_t::ofs_meshs, dpmmesh_t::ofs_texcoords, dpmmesh_t::ofs_verts, dpmbonevert_t::origin, aliasbone_t::parent, model_t::PointSuperContents, R_ConcatTransforms(), R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), r_smoothnormals_areaweighting, model_t::radius, model_t::radius2, model_t::rotatedmaxs, model_t::rotatedmins, dpmmesh_t::shadername, model_t::skinscenes, ST_RAND, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, model_t::surfmesh, model_t::synctype, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, dpmheader_t::type, model_t::type, VectorLength, VectorNormalize, model_t::yawmaxs, model_t::yawmins, dpmheader_t::yawradius, Z_Free, and Z_Malloc.

Mod_FindName()

model_t * Mod_FindName	(	const char *	name,
		const char *	parentname )

Definition at line 595 of file model_shared.c.

{
    int i;
    int nummodels;
    model_t *mod;
 
    if (!parentname)
        parentname = "";
 
    nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
 
    if (!name[0])
        Host_Error ("Mod_ForName: empty name");
 
    // search the currently loaded models
    for (i = 0;i < nummodels;i++)
    {
        if ((mod = (model_t*) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && !strcmp(mod->name, name) && ((!mod->brush.parentmodel && !parentname[0]) || (mod->brush.parentmodel && parentname[0] && !strcmp(mod->brush.parentmodel->name, parentname))))
        {
            mod->used = true;
            return mod;
        }
    }
 
    // no match found, create a new one
    mod = (model_t *) Mem_ExpandableArray_AllocRecord(&models);
    dp_strlcpy(mod->name, name, sizeof(mod->name));
    if (parentname[0])
        mod->brush.parentmodel = Mod_FindName(parentname, NULL);
    else
        mod->brush.parentmodel = NULL;
    mod->loaded = false;
    mod->used = true;
    return mod;
}

References dp_strlcpy, Host_Error(), i, int(), Mem_ExpandableArray_AllocRecord(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), mod(), Mod_FindName(), models, name, and NULL.

Referenced by CL_ParseServerInfo(), Mod_FindName(), Mod_ForName(), Mod_OBJ_Load(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), QW_CL_RequestNextDownload(), SV_ModelIndex(), and VM_CL_effect().

Mod_ForName()

model_t * Mod_ForName	(	const char *	name,
		qbool	crash,
		qbool	checkdisk,
		const char *	parentname )

Definition at line 640 of file model_shared.c.

{
    model_t *model;
 
    // FIXME: So we don't crash if a server is started early.
    if(!vid_opened)
        CL_StartVideo();
 
    model = Mod_FindName(name, parentname);
    if (!model->loaded || checkdisk)
        Mod_LoadModel(model, crash, checkdisk);
    return model;
}

References CL_StartVideo(), crash(), Mod_FindName(), Mod_LoadModel(), model, name, and vid_opened.

Referenced by CL_BeginDownloads(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ParseTempEntity(), Mod_Decompile_f(), Mod_Precache_f(), QW_CL_RequestNextDownload(), SV_Loadgame_f(), SV_ModelIndex(), SV_SpawnServer(), SV_Viewmodel_f(), and VM_CL_precache_model().

Mod_FreeQ3Shaders()

void Mod_FreeQ3Shaders

(

void

)

Definition at line 1403 of file model_shared.c.

{
    Mem_FreePool(&q3shaders_mem);
}

References Mem_FreePool, and q3shaders_mem.

Referenced by CL_BeginDownloads(), CL_SignonReply(), Mod_LoadQ3Shaders(), mod_shutdown(), and SV_SpawnServer().

Mod_FreeSkinFiles()

void Mod_FreeSkinFiles

(

skinfile_t *

skinfile

)

Definition at line 2810 of file model_shared.c.

{
    skinfile_t *next;
    skinfileitem_t *skinfileitem, *nextitem;
    for (;skinfile;skinfile = next)
    {
        next = skinfile->next;
        for (skinfileitem = skinfile->items;skinfileitem;skinfileitem = nextitem)
        {
            nextitem = skinfileitem->next;
            Mem_Free(skinfileitem);
        }
        Mem_Free(skinfile);
    }
}

References skinfile_t::items, Mem_Free, skinfile_t::next, and skinfileitem_t::next.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_HLBSP_Load()

void Mod_HLBSP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 3896 of file model_brush.c.

{
    mod->brush.ishlbsp = true;
    mod->modeldatatypestring = "HLBSP";
    Mod_Q1BSP_Load(mod, buffer, bufferend);
}

References buffer, mod(), and Mod_Q1BSP_Load().

Mod_IBSP_Load()

void Mod_IBSP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 7876 of file model_brush.c.

{
    int i = LittleLong(((int *)buffer)[1]);
    if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE)
        Mod_Q3BSP_Load(mod,buffer, bufferend);
    else if (i == Q2BSPVERSION)
        Mod_Q2BSP_Load(mod,buffer, bufferend);
    else
        Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
}

References buffer, Host_Error(), i, LittleLong, mod(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), Q2BSPVERSION, Q3BSPVERSION, Q3BSPVERSION_IG, and Q3BSPVERSION_LIVE.

Mod_IDP0_Load()

void Mod_IDP0_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 972 of file model_alias.c.

{
    int i, j, version, totalskins, skinwidth, skinheight, groupframes, groupskins, numverts;
    float scales, scalet, interval;
    msurface_t *surface;
    unsigned char *data;
    mdl_t *pinmodel;
    stvert_t *pinstverts;
    dtriangle_t *pintriangles;
    daliasskintype_t *pinskintype;
    daliasskingroup_t *pinskingroup;
    daliasskininterval_t *pinskinintervals;
    daliasframetype_t *pinframetype;
    daliasgroup_t *pinframegroup;
    unsigned char *datapointer, *startframes, *startskins;
    char name[MAX_QPATH];
    skinframe_t *tempskinframe;
    animscene_t *tempskinscenes;
    texture_t *tempaliasskins;
    float *vertst;
    int *vertonseam, *vertremap;
    skinfile_t *skinfiles;
 
    datapointer = (unsigned char *)buffer;
    pinmodel = (mdl_t *)datapointer;
    datapointer += sizeof(mdl_t);
 
    version = LittleLong (pinmodel->version);
    if (version != ALIAS_VERSION)
        Host_Error ("%s has wrong version number (%i should be %i)",
                 loadmodel->name, version, ALIAS_VERSION);
 
    loadmodel->modeldatatypestring = "MDL";
 
    loadmodel->type = mod_alias;
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    // FIXME add TraceBrush!
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_MDL_AnimateVertices;
 
    loadmodel->num_surfaces = 1;
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces;
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int));
    loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
    loadmodel->modelsurfaces_sorted = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->modelsurfaces_sorted[0] = 0;
 
    loadmodel->numskins = LittleLong(pinmodel->numskins);
    BOUNDI(loadmodel->numskins,0,65536);
    skinwidth = LittleLong (pinmodel->skinwidth);
    BOUNDI(skinwidth,0,65536);
    skinheight = LittleLong (pinmodel->skinheight);
    BOUNDI(skinheight,0,65536);
    numverts = LittleLong(pinmodel->numverts);
    BOUNDI(numverts,0,65536);
    loadmodel->surfmesh.num_triangles = LittleLong(pinmodel->numtris);
    BOUNDI(loadmodel->surfmesh.num_triangles,0,65536);
    loadmodel->numframes = LittleLong(pinmodel->numframes);
    BOUNDI(loadmodel->numframes,0,65536);
    loadmodel->synctype = (synctype_t)LittleLong (pinmodel->synctype);
    BOUNDI((int)loadmodel->synctype,0,2);
    // convert model flags to EF flags (MF_ROCKET becomes EF_ROCKET, etc)
    i = LittleLong (pinmodel->flags);
    loadmodel->effects = (((unsigned)i & 255) << 24) | (i & 0x00FFFF00);
 
    if (strstr(r_nolerp_list.string, loadmodel->name))
        loadmodel->nolerp = true;
 
    for (i = 0;i < 3;i++)
    {
        loadmodel->surfmesh.num_morphmdlframescale[i] = LittleFloat (pinmodel->scale[i]);
        loadmodel->surfmesh.num_morphmdlframetranslate[i] = LittleFloat (pinmodel->scale_origin[i]);
    }
 
    startskins = datapointer;
    totalskins = 0;
    for (i = 0;i < loadmodel->numskins;i++)
    {
        pinskintype = (daliasskintype_t *)datapointer;
        datapointer += sizeof(daliasskintype_t);
        if (LittleLong(pinskintype->type) == ALIAS_SKIN_SINGLE)
            groupskins = 1;
        else
        {
            pinskingroup = (daliasskingroup_t *)datapointer;
            datapointer += sizeof(daliasskingroup_t);
            groupskins = LittleLong(pinskingroup->numskins);
            datapointer += sizeof(daliasskininterval_t) * groupskins;
        }
 
        for (j = 0;j < groupskins;j++)
        {
            datapointer += skinwidth * skinheight;
            totalskins++;
        }
    }
 
    pinstverts = (stvert_t *)datapointer;
    datapointer += sizeof(stvert_t) * numverts;
 
    pintriangles = (dtriangle_t *)datapointer;
    datapointer += sizeof(dtriangle_t) * loadmodel->surfmesh.num_triangles;
 
    startframes = datapointer;
    loadmodel->surfmesh.num_morphframes = 0;
    for (i = 0;i < loadmodel->numframes;i++)
    {
        pinframetype = (daliasframetype_t *)datapointer;
        datapointer += sizeof(daliasframetype_t);
        if (LittleLong (pinframetype->type) == ALIAS_SINGLE)
            groupframes = 1;
        else
        {
            pinframegroup = (daliasgroup_t *)datapointer;
            datapointer += sizeof(daliasgroup_t);
            groupframes = LittleLong(pinframegroup->numframes);
            datapointer += sizeof(daliasinterval_t) * groupframes;
        }
 
        for (j = 0;j < groupframes;j++)
        {
            datapointer += sizeof(daliasframe_t);
            datapointer += sizeof(trivertx_t) * numverts;
            loadmodel->surfmesh.num_morphframes++;
        }
    }
    loadmodel->num_poses = loadmodel->surfmesh.num_morphframes;
 
    // store texture coordinates into temporary array, they will be stored
    // after usage is determined (triangle data)
    vertst = (float *)Mem_Alloc(tempmempool, numverts * 2 * sizeof(float[2]));
    vertremap = (int *)Mem_Alloc(tempmempool, numverts * 3 * sizeof(int));
    vertonseam = vertremap + numverts * 2;
 
    scales = 1.0 / skinwidth;
    scalet = 1.0 / skinheight;
    for (i = 0;i < numverts;i++)
    {
        vertonseam[i] = LittleLong(pinstverts[i].onseam);
        vertst[i*2+0] = LittleLong(pinstverts[i].s) * scales;
        vertst[i*2+1] = LittleLong(pinstverts[i].t) * scalet;
        vertst[(i+numverts)*2+0] = vertst[i*2+0] + 0.5;
        vertst[(i+numverts)*2+1] = vertst[i*2+1];
    }
 
// load triangle data
    loadmodel->surfmesh.data_element3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * loadmodel->surfmesh.num_triangles);
 
    // read the triangle elements
    for (i = 0;i < loadmodel->surfmesh.num_triangles;i++)
        for (j = 0;j < 3;j++)
            loadmodel->surfmesh.data_element3i[i*3+j] = LittleLong(pintriangles[i].vertindex[j]);
    // validate (note numverts is used because this is the original data)
    Mod_ValidateElements(loadmodel->surfmesh.data_element3i, NULL, loadmodel->surfmesh.num_triangles, 0, numverts, __FILE__, __LINE__);
    // now butcher the elements according to vertonseam and tri->facesfront
    // and then compact the vertex set to remove duplicates
    for (i = 0;i < loadmodel->surfmesh.num_triangles;i++)
        if (!LittleLong(pintriangles[i].facesfront)) // backface
            for (j = 0;j < 3;j++)
                if (vertonseam[loadmodel->surfmesh.data_element3i[i*3+j]])
                    loadmodel->surfmesh.data_element3i[i*3+j] += numverts;
    // count the usage
    // (this uses vertremap to count usage to save some memory)
    for (i = 0;i < numverts*2;i++)
        vertremap[i] = 0;
    for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
        vertremap[loadmodel->surfmesh.data_element3i[i]]++;
    // build remapping table and compact array
    loadmodel->surfmesh.num_vertices = 0;
    for (i = 0;i < numverts*2;i++)
    {
        if (vertremap[i])
        {
            vertremap[i] = loadmodel->surfmesh.num_vertices;
            vertst[loadmodel->surfmesh.num_vertices*2+0] = vertst[i*2+0];
            vertst[loadmodel->surfmesh.num_vertices*2+1] = vertst[i*2+1];
            loadmodel->surfmesh.num_vertices++;
        }
        else
            vertremap[i] = -1; // not used at all
    }
    // remap the elements to the new vertex set
    for (i = 0;i < loadmodel->surfmesh.num_triangles * 3;i++)
        loadmodel->surfmesh.data_element3i[i] = vertremap[loadmodel->surfmesh.data_element3i[i]];
    // store the texture coordinates
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[2]) * loadmodel->surfmesh.num_vertices);
    for (i = 0;i < loadmodel->surfmesh.num_vertices;i++)
    {
        loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = vertst[i*2+0];
        loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = vertst[i*2+1];
    }
 
    // generate ushort elements array if possible
    if (loadmodel->surfmesh.num_vertices <= 65536)
        loadmodel->surfmesh.data_element3s = (unsigned short *)Mem_Alloc(loadmodel->mempool, sizeof(unsigned short[3]) * loadmodel->surfmesh.num_triangles);
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
 
// load the frames
    loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numframes);
    loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)Mem_Alloc(loadmodel->mempool, sizeof(trivertx_t) * loadmodel->surfmesh.num_morphframes * loadmodel->surfmesh.num_vertices);
    Mod_MDL_LoadFrames (startframes, numverts, vertremap);
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    Mod_Alias_MorphMesh_CompileFrames();
 
    Mem_Free(vertst);
    Mem_Free(vertremap);
 
    // load the skins
    skinfiles = Mod_LoadSkinFiles();
    if (skinfiles)
    {
        loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, loadmodel->numskins * sizeof(animscene_t));
        loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
        loadmodel->num_texturesperskin = loadmodel->num_surfaces;
        loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures, skinfiles, "default", "");
        Mod_FreeSkinFiles(skinfiles);
        for (i = 0;i < loadmodel->numskins;i++)
        {
            loadmodel->skinscenes[i].firstframe = i;
            loadmodel->skinscenes[i].framecount = 1;
            loadmodel->skinscenes[i].loop = true;
            loadmodel->skinscenes[i].framerate = 10;
        }
    }
    else
    {
        loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, loadmodel->numskins * sizeof(animscene_t));
        loadmodel->num_textures = loadmodel->num_surfaces * totalskins;
        loadmodel->num_texturesperskin = loadmodel->num_surfaces;
        loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * totalskins * sizeof(texture_t));
        totalskins = 0;
        datapointer = startskins;
        for (i = 0;i < loadmodel->numskins;i++)
        {
            pinskintype = (daliasskintype_t *)datapointer;
            datapointer += sizeof(daliasskintype_t);
 
            if (pinskintype->type == ALIAS_SKIN_SINGLE)
            {
                groupskins = 1;
                interval = 0.1f;
            }
            else
            {
                pinskingroup = (daliasskingroup_t *)datapointer;
                datapointer += sizeof(daliasskingroup_t);
 
                groupskins = LittleLong (pinskingroup->numskins);
 
                pinskinintervals = (daliasskininterval_t *)datapointer;
                datapointer += sizeof(daliasskininterval_t) * groupskins;
 
                interval = LittleFloat(pinskinintervals[0].interval);
                if (interval < 0.01f)
                {
                    Con_Printf("%s has an invalid interval %f, changing to 0.1\n", loadmodel->name, interval);
                    interval = 0.1f;
                }
            }
 
            dpsnprintf(loadmodel->skinscenes[i].name, sizeof(loadmodel->skinscenes[i].name), "skin %i", i);
            loadmodel->skinscenes[i].firstframe = totalskins;
            loadmodel->skinscenes[i].framecount = groupskins;
            loadmodel->skinscenes[i].framerate = 1.0f / interval;
            loadmodel->skinscenes[i].loop = true;
 
            for (j = 0;j < groupskins;j++)
            {
                if (groupskins > 1)
                    dpsnprintf (name, sizeof(name), "%s_%i_%i", loadmodel->name, i, j);
                else
                    dpsnprintf (name, sizeof(name), "%s_%i", loadmodel->name, i);
                if (!Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, loadmodel->data_textures + totalskins * loadmodel->num_surfaces, name, false, false, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL))
                    Mod_LoadCustomMaterial(loadmodel->mempool, loadmodel->data_textures + totalskins * loadmodel->num_surfaces, name, SUPERCONTENTS_SOLID, MATERIALFLAG_WALL, R_SkinFrame_LoadInternalQuake(name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_PICMIP, true, r_fullbrights.integer, (unsigned char *)datapointer, skinwidth, skinheight));
                datapointer += skinwidth * skinheight;
                totalskins++;
            }
        }
        // check for skins that don't exist in the model, but do exist as external images
        // (this was added because yummyluv kept pestering me about support for it)
        // TODO: support shaders here?
        for (;;)
        {
            dpsnprintf(name, sizeof(name), "%s_%i", loadmodel->name, loadmodel->numskins);
            tempskinframe = R_SkinFrame_LoadExternal(name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS, false, false);
            if (!tempskinframe)
                break;
            // expand the arrays to make room
            tempskinscenes = loadmodel->skinscenes;
            loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, (loadmodel->numskins + 1) * sizeof(animscene_t));
            memcpy(loadmodel->skinscenes, tempskinscenes, loadmodel->numskins * sizeof(animscene_t));
            Mem_Free(tempskinscenes);
 
            tempaliasskins = loadmodel->data_textures;
            loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * (totalskins + 1) * sizeof(texture_t));
            memcpy(loadmodel->data_textures, tempaliasskins, loadmodel->num_surfaces * totalskins * sizeof(texture_t));
            Mem_Free(tempaliasskins);
 
            // store the info about the new skin
            Mod_LoadCustomMaterial(loadmodel->mempool, loadmodel->data_textures + totalskins * loadmodel->num_surfaces, name, SUPERCONTENTS_SOLID, MATERIALFLAG_WALL, tempskinframe);
            dp_strlcpy(loadmodel->skinscenes[loadmodel->numskins].name, name, sizeof(loadmodel->skinscenes[loadmodel->numskins].name));
            loadmodel->skinscenes[loadmodel->numskins].firstframe = totalskins;
            loadmodel->skinscenes[loadmodel->numskins].framecount = 1;
            loadmodel->skinscenes[loadmodel->numskins].framerate = 10.0f;
            loadmodel->skinscenes[loadmodel->numskins].loop = true;
 
            //increase skin counts
            loadmodel->num_textures++;
            loadmodel->numskins++;
            totalskins++;
 
            // fix up the pointers since they are pointing at the old textures array
            // FIXME: this is a hack!
            for (j = 0;j < loadmodel->numskins * loadmodel->num_surfaces;j++)
                loadmodel->data_textures[j].currentframe = &loadmodel->data_textures[j];
        }
    }
 
    surface = loadmodel->data_surfaces;
    surface->texture = loadmodel->data_textures;
    surface->num_firsttriangle = 0;
    surface->num_triangles = loadmodel->surfmesh.num_triangles;
    surface->num_firstvertex = 0;
    surface->num_vertices = loadmodel->surfmesh.num_vertices;
 
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References ALIAS_SINGLE, ALIAS_SKIN_SINGLE, ALIAS_VERSION, model_t::AnimateVertices, model_t::animscenes, BOUNDI, buffer, model_t::collision_bih, model_t::CompileShadowMap, Con_Printf(), texture_t::currentframe, data, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_morphmdlvertex, model_t::data_surfaces, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, dp_strlcpy, dpsnprintf(), model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, model_t::effects, animscene_t::firstframe, mdl_t::flags, animscene_t::framecount, animscene_t::framerate, Host_Error(), i, int(), cvar_t::integer, surfmesh_t::isanimated, LittleFloat, LittleLong, loadmodel, animscene_t::loop, MATERIALFLAG_WALL, MAX_QPATH, Mem_Alloc, Mem_Free, model_t::mempool, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_Alias_MorphMesh_CompileFrames(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadCustomMaterial(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MakeCollisionBIH(), Mod_MDL_AnimateVertices(), Mod_MDL_LoadFrames(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, animscene_t::name, model_t::name, name, model_t::nolerp, NULL, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, surfmesh_t::num_morphframes, surfmesh_t::num_morphmdlframescale, surfmesh_t::num_morphmdlframetranslate, model_t::num_poses, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, msurface_t::num_vertices, surfmesh_t::num_vertices, daliasgroup_t::numframes, mdl_t::numframes, model_t::numframes, daliasskingroup_t::numskins, mdl_t::numskins, model_t::numskins, mdl_t::numtris, mdl_t::numverts, model_t::PointSuperContents, r_fullbrights, r_mipskins, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), r_nolerp_list, R_SkinFrame_LoadExternal(), R_SkinFrame_LoadInternalQuake(), mdl_t::scale, mdl_t::scale_origin, mdl_t::skinheight, model_t::skinscenes, mdl_t::skinwidth, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, SUPERCONTENTS_SOLID, model_t::surfmesh, mdl_t::synctype, model_t::synctype, tempmempool, TEXF_ALPHA, TEXF_COMPRESS, TEXF_MIPMAP, TEXF_PICMIP, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, daliasframetype_t::type, daliasskintype_t::type, model_t::type, mdl_t::version, and version.

Mod_IDP2_Load()

void Mod_IDP2_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 1324 of file model_alias.c.

{
    int i, j, hashindex, numxyz, numst, xyz, st, skinwidth, skinheight, *vertremap, version, end;
    float iskinwidth, iskinheight;
    unsigned char *data;
    msurface_t *surface;
    md2_t *pinmodel;
    unsigned char *base, *datapointer;
    md2frame_t *pinframe;
    char *inskin;
    md2triangle_t *intri;
    unsigned short *inst;
    struct md2verthash_s
    {
        struct md2verthash_s *next;
        unsigned short xyz;
        unsigned short st;
    }
    *hash, **md2verthash, *md2verthashdata;
    skinfile_t *skinfiles;
 
    pinmodel = (md2_t *)buffer;
    base = (unsigned char *)buffer;
 
    version = LittleLong (pinmodel->version);
    if (version != MD2ALIAS_VERSION)
        Host_Error ("%s has wrong version number (%i should be %i)",
            loadmodel->name, version, MD2ALIAS_VERSION);
 
    loadmodel->modeldatatypestring = "MD2";
 
    loadmodel->type = mod_alias;
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_MDL_AnimateVertices;
 
    if (LittleLong(pinmodel->num_tris) < 1 || LittleLong(pinmodel->num_tris) > 65536)
        Host_Error ("%s has invalid number of triangles: %i", loadmodel->name, LittleLong(pinmodel->num_tris));
    if (LittleLong(pinmodel->num_xyz) < 1 || LittleLong(pinmodel->num_xyz) > 65536)
        Host_Error ("%s has invalid number of vertices: %i", loadmodel->name, LittleLong(pinmodel->num_xyz));
    if (LittleLong(pinmodel->num_frames) < 1 || LittleLong(pinmodel->num_frames) > 65536)
        Host_Error ("%s has invalid number of frames: %i", loadmodel->name, LittleLong(pinmodel->num_frames));
    if (LittleLong(pinmodel->num_skins) < 0 || LittleLong(pinmodel->num_skins) > 256)
        Host_Error ("%s has invalid number of skins: %i", loadmodel->name, LittleLong(pinmodel->num_skins));
 
    end = LittleLong(pinmodel->ofs_end);
    if (LittleLong(pinmodel->num_skins) >= 1 && (LittleLong(pinmodel->ofs_skins) <= 0 || LittleLong(pinmodel->ofs_skins) >= end))
        Host_Error ("%s is not a valid model", loadmodel->name);
    if (LittleLong(pinmodel->ofs_st) <= 0 || LittleLong(pinmodel->ofs_st) >= end)
        Host_Error ("%s is not a valid model", loadmodel->name);
    if (LittleLong(pinmodel->ofs_tris) <= 0 || LittleLong(pinmodel->ofs_tris) >= end)
        Host_Error ("%s is not a valid model", loadmodel->name);
    if (LittleLong(pinmodel->ofs_frames) <= 0 || LittleLong(pinmodel->ofs_frames) >= end)
        Host_Error ("%s is not a valid model", loadmodel->name);
    if (LittleLong(pinmodel->ofs_glcmds) <= 0 || LittleLong(pinmodel->ofs_glcmds) >= end)
        Host_Error ("%s is not a valid model", loadmodel->name);
 
    loadmodel->numskins = LittleLong(pinmodel->num_skins);
    numxyz = LittleLong(pinmodel->num_xyz);
    numst = LittleLong(pinmodel->num_st);
    loadmodel->surfmesh.num_triangles = LittleLong(pinmodel->num_tris);
    loadmodel->numframes = LittleLong(pinmodel->num_frames);
    loadmodel->surfmesh.num_morphframes = loadmodel->numframes;
    loadmodel->num_poses = loadmodel->surfmesh.num_morphframes;
    skinwidth = LittleLong(pinmodel->skinwidth);
    skinheight = LittleLong(pinmodel->skinheight);
    iskinwidth = 1.0f / skinwidth;
    iskinheight = 1.0f / skinheight;
 
    loadmodel->num_surfaces = 1;
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces;
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->numframes * sizeof(animscene_t) + loadmodel->numframes * sizeof(float[6]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]));
    loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
    loadmodel->modelsurfaces_sorted = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->modelsurfaces_sorted[0] = 0;
    loadmodel->animscenes = (animscene_t *)data;data += loadmodel->numframes * sizeof(animscene_t);
    loadmodel->surfmesh.data_morphmd2framesize6f = (float *)data;data += loadmodel->numframes * sizeof(float[6]);
    loadmodel->surfmesh.data_element3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
 
    loadmodel->synctype = ST_RAND;
 
    // load the skins
    inskin = (char *)(base + LittleLong(pinmodel->ofs_skins));
    skinfiles = Mod_LoadSkinFiles();
    if (skinfiles)
    {
        loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
        loadmodel->num_texturesperskin = loadmodel->num_surfaces;
        loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures, skinfiles, "default", "");
        Mod_FreeSkinFiles(skinfiles);
    }
    else if (loadmodel->numskins)
    {
        // skins found (most likely not a player model)
        loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
        loadmodel->num_texturesperskin = loadmodel->num_surfaces;
        loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
        for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
            Mod_LoadTextureFromQ3Shader(loadmodel->mempool, loadmodel->name, loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS, MATERIALFLAG_WALL);
    }
    else
    {
        // no skins (most likely a player model)
        loadmodel->numskins = 1;
        loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
        loadmodel->num_texturesperskin = loadmodel->num_surfaces;
        loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
        Mod_LoadCustomMaterial(loadmodel->mempool, loadmodel->data_textures, loadmodel->name, SUPERCONTENTS_SOLID, MATERIALFLAG_WALL, R_SkinFrame_LoadMissing());
    }
 
    loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // load the triangles and stvert data
    inst = (unsigned short *)(base + LittleLong(pinmodel->ofs_st));
    intri = (md2triangle_t *)(base + LittleLong(pinmodel->ofs_tris));
    md2verthash = (struct md2verthash_s **)Mem_Alloc(tempmempool, 65536 * sizeof(hash));
    md2verthashdata = (struct md2verthash_s *)Mem_Alloc(tempmempool, loadmodel->surfmesh.num_triangles * 3 * sizeof(*hash));
    // swap the triangle list
    loadmodel->surfmesh.num_vertices = 0;
    for (i = 0;i < loadmodel->surfmesh.num_triangles;i++)
    {
        for (j = 0;j < 3;j++)
        {
            xyz = (unsigned short) LittleShort (intri[i].index_xyz[j]);
            st = (unsigned short) LittleShort (intri[i].index_st[j]);
            if (xyz >= numxyz)
            {
                Con_Printf("%s has an invalid xyz index (%i) on triangle %i, resetting to 0\n", loadmodel->name, xyz, i);
                xyz = 0;
            }
            if (st >= numst)
            {
                Con_Printf("%s has an invalid st index (%i) on triangle %i, resetting to 0\n", loadmodel->name, st, i);
                st = 0;
            }
            hashindex = (xyz * 256 + st) & 65535;
            for (hash = md2verthash[hashindex];hash;hash = hash->next)
                if (hash->xyz == xyz && hash->st == st)
                    break;
            if (hash == NULL)
            {
                hash = md2verthashdata + loadmodel->surfmesh.num_vertices++;
                hash->xyz = xyz;
                hash->st = st;
                hash->next = md2verthash[hashindex];
                md2verthash[hashindex] = hash;
            }
            loadmodel->surfmesh.data_element3i[i*3+j] = (hash - md2verthashdata);
        }
    }
 
    vertremap = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(int));
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->surfmesh.num_vertices * sizeof(float[2]) + loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t));
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
    loadmodel->surfmesh.data_morphmdlvertex = (trivertx_t *)data;data += loadmodel->surfmesh.num_vertices * loadmodel->surfmesh.num_morphframes * sizeof(trivertx_t);
    for (i = 0;i < loadmodel->surfmesh.num_vertices;i++)
    {
        int sts, stt;
        hash = md2verthashdata + i;
        vertremap[i] = hash->xyz;
        sts = LittleShort(inst[hash->st*2+0]);
        stt = LittleShort(inst[hash->st*2+1]);
        if (sts < 0 || sts >= skinwidth || stt < 0 || stt >= skinheight)
        {
            Con_Printf("%s has an invalid skin coordinate (%i %i) on vert %i, changing to 0 0\n", loadmodel->name, sts, stt, i);
            sts = 0;
            stt = 0;
        }
        loadmodel->surfmesh.data_texcoordtexture2f[i*2+0] = sts * iskinwidth;
        loadmodel->surfmesh.data_texcoordtexture2f[i*2+1] = stt * iskinheight;
    }
 
    Mem_Free(md2verthash);
    Mem_Free(md2verthashdata);
 
    // generate ushort elements array if possible
    if (loadmodel->surfmesh.num_vertices <= 65536)
        loadmodel->surfmesh.data_element3s = (unsigned short *)Mem_Alloc(loadmodel->mempool, sizeof(unsigned short[3]) * loadmodel->surfmesh.num_triangles);
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
 
    // load the frames
    datapointer = (base + LittleLong(pinmodel->ofs_frames));
    for (i = 0;i < loadmodel->surfmesh.num_morphframes;i++)
    {
        int k;
        trivertx_t *v;
        trivertx_t *out;
        pinframe = (md2frame_t *)datapointer;
        datapointer += sizeof(md2frame_t);
        // store the frame scale/translate into the appropriate array
        for (j = 0;j < 3;j++)
        {
            loadmodel->surfmesh.data_morphmd2framesize6f[i*6+j] = LittleFloat(pinframe->scale[j]);
            loadmodel->surfmesh.data_morphmd2framesize6f[i*6+3+j] = LittleFloat(pinframe->translate[j]);
        }
        // convert the vertices
        v = (trivertx_t *)datapointer;
        out = loadmodel->surfmesh.data_morphmdlvertex + i * loadmodel->surfmesh.num_vertices;
        for (k = 0;k < loadmodel->surfmesh.num_vertices;k++)
            out[k] = v[vertremap[k]];
        datapointer += numxyz * sizeof(trivertx_t);
 
        dp_strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name));
        loadmodel->animscenes[i].firstframe = i;
        loadmodel->animscenes[i].framecount = 1;
        loadmodel->animscenes[i].framerate = 10;
        loadmodel->animscenes[i].loop = true;
    }
 
    Mem_Free(vertremap);
 
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    Mod_Alias_MorphMesh_CompileFrames();
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    surface = loadmodel->data_surfaces;
    surface->texture = loadmodel->data_textures;
    surface->num_firsttriangle = 0;
    surface->num_triangles = loadmodel->surfmesh.num_triangles;
    surface->num_firstvertex = 0;
    surface->num_vertices = loadmodel->surfmesh.num_vertices;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References model_t::AnimateVertices, model_t::animscenes, buffer, model_t::collision_bih, model_t::CompileShadowMap, Con_Printf(), data, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_morphmd2framesize6f, surfmesh_t::data_morphmdlvertex, model_t::data_surfaces, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, dp_strlcpy, model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, animscene_t::firstframe, animscene_t::framecount, animscene_t::framerate, Host_Error(), i, int(), cvar_t::integer, surfmesh_t::isanimated, LittleFloat, LittleLong, LittleShort, loadmodel, animscene_t::loop, MATERIALFLAG_WALL, MD2_SKINNAME, MD2ALIAS_VERSION, Mem_Alloc, Mem_Free, model_t::mempool, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_Alias_MorphMesh_CompileFrames(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadCustomMaterial(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MakeCollisionBIH(), Mod_MDL_AnimateVertices(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, animscene_t::name, md2frame_t::name, model_t::name, NULL, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, md2_t::num_frames, surfmesh_t::num_morphframes, model_t::num_poses, md2_t::num_skins, md2_t::num_st, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, md2_t::num_tris, msurface_t::num_vertices, surfmesh_t::num_vertices, md2_t::num_xyz, model_t::numframes, model_t::numskins, md2_t::ofs_end, md2_t::ofs_frames, md2_t::ofs_glcmds, md2_t::ofs_skins, md2_t::ofs_st, md2_t::ofs_tris, model_t::PointSuperContents, r_mipskins, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), R_SkinFrame_LoadMissing(), md2frame_t::scale, md2_t::skinheight, model_t::skinscenes, md2_t::skinwidth, ST_RAND, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, SUPERCONTENTS_SOLID, model_t::surfmesh, model_t::synctype, tempmempool, TEXF_ALPHA, TEXF_COMPRESS, TEXF_MIPMAP, TEXF_PICMIP, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, md2frame_t::translate, model_t::type, v, md2_t::version, version, and xyz.

Mod_IDP3_Load()

void Mod_IDP3_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 1578 of file model_alias.c.

{
    int i, j, k, version, meshvertices, meshtriangles;
    unsigned char *data;
    msurface_t *surface;
    md3modelheader_t *pinmodel;
    md3frameinfo_t *pinframe;
    md3mesh_t *pinmesh;
    md3tag_t *pintag;
    skinfile_t *skinfiles;
 
    pinmodel = (md3modelheader_t *)buffer;
 
    if (memcmp(pinmodel->identifier, "IDP3", 4))
        Host_Error ("%s is not a MD3 (IDP3) file", loadmodel->name);
    version = LittleLong (pinmodel->version);
    if (version != MD3VERSION)
        Host_Error ("%s has wrong version number (%i should be %i)",
            loadmodel->name, version, MD3VERSION);
 
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
 
    loadmodel->modeldatatypestring = "MD3";
 
    loadmodel->type = mod_alias;
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_MD3_AnimateVertices;
    loadmodel->synctype = ST_RAND;
    // convert model flags to EF flags (MF_ROCKET becomes EF_ROCKET, etc)
    i = LittleLong (pinmodel->flags);
    loadmodel->effects = (((unsigned)i & 255) << 24) | (i & 0x00FFFF00);
 
    // set up some global info about the model
    loadmodel->numframes = LittleLong(pinmodel->num_frames);
    loadmodel->num_surfaces = LittleLong(pinmodel->num_meshes);
 
    // make skinscenes for the skins (no groups)
    loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // load frameinfo
    loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, loadmodel->numframes * sizeof(animscene_t));
    for (i = 0, pinframe = (md3frameinfo_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_frameinfo));i < loadmodel->numframes;i++, pinframe++)
    {
        dp_strlcpy(loadmodel->animscenes[i].name, pinframe->name, sizeof(loadmodel->animscenes[i].name));
        loadmodel->animscenes[i].firstframe = i;
        loadmodel->animscenes[i].framecount = 1;
        loadmodel->animscenes[i].framerate = 10;
        loadmodel->animscenes[i].loop = true;
    }
 
    // load tags
    loadmodel->num_tagframes = loadmodel->numframes;
    loadmodel->num_tags = LittleLong(pinmodel->num_tags);
    loadmodel->data_tags = (aliastag_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_tagframes * loadmodel->num_tags * sizeof(aliastag_t));
    for (i = 0, pintag = (md3tag_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_tags));i < loadmodel->num_tagframes * loadmodel->num_tags;i++, pintag++)
    {
        dp_strlcpy(loadmodel->data_tags[i].name, pintag->name, sizeof(loadmodel->data_tags[i].name));
        for (j = 0;j < 9;j++)
            loadmodel->data_tags[i].matrixgl[j] = LittleFloat(pintag->rotationmatrix[j]);
        for (j = 0;j < 3;j++)
            loadmodel->data_tags[i].matrixgl[9+j] = LittleFloat(pintag->origin[j]);
        //Con_Printf("model \"%s\" frame #%i tag #%i \"%s\"\n", loadmodel->name, i / loadmodel->num_tags, i % loadmodel->num_tags, loadmodel->data_tags[i].name);
    }
 
    // load meshes
    meshvertices = 0;
    meshtriangles = 0;
    for (i = 0, pinmesh = (md3mesh_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_meshes));i < loadmodel->num_surfaces;i++, pinmesh = (md3mesh_t *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_end)))
    {
        if (memcmp(pinmesh->identifier, "IDP3", 4))
            Host_Error("Mod_IDP3_Load: invalid mesh identifier (not IDP3)");
        if (LittleLong(pinmesh->num_frames) != loadmodel->numframes)
            Host_Error("Mod_IDP3_Load: mesh numframes differs from header");
        meshvertices += LittleLong(pinmesh->num_vertices);
        meshtriangles += LittleLong(pinmesh->num_triangles);
    }
 
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces;
    loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
    loadmodel->num_texturesperskin = loadmodel->num_surfaces;
    loadmodel->surfmesh.num_vertices = meshvertices;
    loadmodel->surfmesh.num_triangles = meshtriangles;
    loadmodel->surfmesh.num_morphframes = loadmodel->numframes; // TODO: remove?
    loadmodel->num_poses = loadmodel->surfmesh.num_morphframes;
 
    // do most allocations as one merged chunk
    // This is only robust for C standard types!
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool,
        meshvertices * sizeof(float[2])
        + loadmodel->num_surfaces * sizeof(int)
        + meshtriangles * sizeof(int[3])
        + (meshvertices <= 65536 ? meshtriangles * sizeof(unsigned short[3]) : 0));
    // Pointers must be taken in descending order of alignment requirement!
    loadmodel->surfmesh.data_texcoordtexture2f        = (float *)data; data += meshvertices * sizeof(float[2]);
    loadmodel->modelsurfaces_sorted                     = (int *)data; data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->surfmesh.data_element3i                  = (int *)data; data += meshtriangles * sizeof(int[3]);
    if (meshvertices <= 65536)
    {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data; data += meshtriangles * sizeof(unsigned short[3]);
    }
    // Struct alignment requirements could change so we can't assume them here
    // otherwise a safe-looking commit could introduce undefined behaviour!
    loadmodel->data_surfaces = Mem_AllocType(loadmodel->mempool, msurface_t, loadmodel->num_surfaces * sizeof(msurface_t));
    loadmodel->data_textures = Mem_AllocType(loadmodel->mempool, texture_t, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
    loadmodel->surfmesh.data_morphmd3vertex = Mem_AllocType(loadmodel->mempool, md3vertex_t, meshvertices * loadmodel->numframes * sizeof(md3vertex_t));
 
    meshvertices = 0;
    meshtriangles = 0;
    for (i = 0, pinmesh = (md3mesh_t *)((unsigned char *)pinmodel + LittleLong(pinmodel->lump_meshes));i < loadmodel->num_surfaces;i++, pinmesh = (md3mesh_t *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_end)))
    {
        if (memcmp(pinmesh->identifier, "IDP3", 4))
            Host_Error("Mod_IDP3_Load: invalid mesh identifier (not IDP3)");
        loadmodel->modelsurfaces_sorted[i] = i;
        surface = loadmodel->data_surfaces + i;
        surface->texture = loadmodel->data_textures + i;
        surface->num_firsttriangle = meshtriangles;
        surface->num_triangles = LittleLong(pinmesh->num_triangles);
        surface->num_firstvertex = meshvertices;
        surface->num_vertices = LittleLong(pinmesh->num_vertices);
        meshvertices += surface->num_vertices;
        meshtriangles += surface->num_triangles;
 
        for (j = 0;j < surface->num_triangles * 3;j++)
        {
            int e = surface->num_firstvertex + LittleLong(((int *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_elements)))[j]);
            loadmodel->surfmesh.data_element3i[j + surface->num_firsttriangle * 3] = e;
            if (loadmodel->surfmesh.data_element3s)
                loadmodel->surfmesh.data_element3s[j + surface->num_firsttriangle * 3] = e;
        }
        for (j = 0;j < surface->num_vertices;j++)
        {
            loadmodel->surfmesh.data_texcoordtexture2f[(j + surface->num_firstvertex) * 2 + 0] = LittleFloat(((float *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_texcoords)))[j * 2 + 0]);
            loadmodel->surfmesh.data_texcoordtexture2f[(j + surface->num_firstvertex) * 2 + 1] = LittleFloat(((float *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_texcoords)))[j * 2 + 1]);
        }
        for (j = 0;j < loadmodel->numframes;j++)
        {
            const md3vertex_t *in = (md3vertex_t *)((unsigned char *)pinmesh + LittleLong(pinmesh->lump_framevertices)) + j * surface->num_vertices;
            md3vertex_t *out = loadmodel->surfmesh.data_morphmd3vertex + surface->num_firstvertex + j * loadmodel->surfmesh.num_vertices;
            for (k = 0;k < surface->num_vertices;k++, in++, out++)
            {
                out->origin[0] = LittleShort(in->origin[0]);
                out->origin[1] = LittleShort(in->origin[1]);
                out->origin[2] = LittleShort(in->origin[2]);
                out->pitch = in->pitch;
                out->yaw = in->yaw;
            }
        }
 
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + i, skinfiles, pinmesh->name, LittleLong(pinmesh->num_shaders) >= 1 ? ((md3shader_t *)((unsigned char *) pinmesh + LittleLong(pinmesh->lump_shaders)))->name : "");
 
        Mod_ValidateElements(loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3, loadmodel->surfmesh.data_element3s + surface->num_firsttriangle * 3, surface->num_triangles, surface->num_firstvertex, surface->num_vertices, __FILE__, __LINE__);
    }
    Mod_Alias_MorphMesh_CompileFrames();
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    Mod_FreeSkinFiles(skinfiles);
    Mod_MakeSortedSurfaces(loadmodel);
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References model_t::AnimateVertices, model_t::animscenes, buffer, model_t::collision_bih, model_t::CompileShadowMap, data, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_morphmd3vertex, model_t::data_surfaces, model_t::data_tags, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, dp_strlcpy, model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, model_t::effects, animscene_t::firstframe, md3modelheader_t::flags, animscene_t::framecount, animscene_t::framerate, Host_Error(), i, md3mesh_t::identifier, md3modelheader_t::identifier, int(), cvar_t::integer, surfmesh_t::isanimated, LittleFloat, LittleLong, LittleShort, loadmodel, animscene_t::loop, md3mesh_t::lump_elements, md3mesh_t::lump_end, md3modelheader_t::lump_frameinfo, md3mesh_t::lump_framevertices, md3modelheader_t::lump_meshes, md3mesh_t::lump_shaders, md3modelheader_t::lump_tags, md3mesh_t::lump_texcoords, aliastag_t::matrixgl, MD3VERSION, Mem_Alloc, Mem_AllocType, model_t::mempool, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_Alias_MorphMesh_CompileFrames(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MD3_AnimateVertices(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, aliastag_t::name, animscene_t::name, md3frameinfo_t::name, md3mesh_t::name, md3tag_t::name, model_t::name, NULL, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, md3mesh_t::num_frames, md3modelheader_t::num_frames, md3modelheader_t::num_meshes, surfmesh_t::num_morphframes, model_t::num_poses, md3mesh_t::num_shaders, model_t::num_surfaces, model_t::num_tagframes, md3modelheader_t::num_tags, model_t::num_tags, model_t::num_textures, model_t::num_texturesperskin, md3mesh_t::num_triangles, msurface_t::num_triangles, surfmesh_t::num_triangles, md3mesh_t::num_vertices, msurface_t::num_vertices, surfmesh_t::num_vertices, model_t::numframes, model_t::numskins, md3tag_t::origin, md3vertex_t::origin, md3vertex_t::pitch, model_t::PointSuperContents, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), md3tag_t::rotationmatrix, model_t::skinscenes, ST_RAND, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, model_t::surfmesh, model_t::synctype, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, model_t::type, md3modelheader_t::version, version, and md3vertex_t::yaw.

Mod_IDS2_Load()

void Mod_IDS2_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 378 of file model_sprite.c.

{
    int i, version;
    qbool fullbright;
    const dsprite2_t *pinqsprite;
    skinframe_t *skinframe;
    float modelradius;
    int texflags = (r_mipsprites.integer ? TEXF_MIPMAP : 0) | TEXF_ISSPRITE | TEXF_PICMIP | TEXF_COMPRESS | TEXF_ALPHA | TEXF_CLAMP;
 
    loadmodel->modeldatatypestring = "SPR2";
 
    loadmodel->type = mod_sprite;
 
    loadmodel->Draw = R_Model_Sprite_Draw;
    loadmodel->DrawDepth = NULL;
    loadmodel->DrawLight = NULL;
 
    pinqsprite = (dsprite2_t *)buffer;
 
    version = LittleLong(pinqsprite->version);
    if (version != SPRITE2_VERSION)
        Host_Error("Mod_IDS2_Load: %s has wrong version number (%i should be 2 (quake 2)", loadmodel->name, version);
 
    loadmodel->numframes = LittleLong (pinqsprite->numframes);
    if (loadmodel->numframes < 1)
        Host_Error ("Mod_IDS2_Load: Invalid # of frames: %d", loadmodel->numframes);
    loadmodel->sprite.sprnum_type = SPR_VP_PARALLEL;
    loadmodel->synctype = ST_SYNC;
 
    // LadyHavoc: hack to allow sprites to be non-fullbright
    fullbright = true;
    for (i = 0;i < MAX_QPATH && loadmodel->name[i];i++)
        if (loadmodel->name[i] == '!')
            fullbright = false;
 
    loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numframes);
    loadmodel->sprite.sprdata_frames = (mspriteframe_t *)Mem_Alloc(loadmodel->mempool, sizeof(mspriteframe_t) * loadmodel->numframes);
    loadmodel->num_textures = loadmodel->numframes;
    loadmodel->num_texturesperskin = 1;
    loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, sizeof(texture_t) * loadmodel->num_textures);
 
    modelradius = 0;
    for (i = 0;i < loadmodel->numframes;i++)
    {
        int origin[2], x, y, width, height;
        const dsprite2frame_t *pinframe;
        mspriteframe_t *sprframe;
 
        dpsnprintf(loadmodel->animscenes[i].name, sizeof(loadmodel->animscenes[i].name), "frame %i", i);
        loadmodel->animscenes[i].firstframe = i;
        loadmodel->animscenes[i].framecount = 1;
        loadmodel->animscenes[i].framerate = 10;
        loadmodel->animscenes[i].loop = true;
 
        pinframe = &pinqsprite->frames[i];
 
        origin[0] = LittleLong (pinframe->origin_x);
        origin[1] = LittleLong (pinframe->origin_y);
        width = LittleLong (pinframe->width);
        height = LittleLong (pinframe->height);
 
        sprframe = &loadmodel->sprite.sprdata_frames[i];
 
        // note that sp2 origin[0] is positive, where as it is negative in
        // spr/spr32/hlspr
        sprframe->left = -origin[0];
        sprframe->right = -origin[0] + width;
        sprframe->up = origin[1];
        sprframe->down = origin[1] - height;
 
        x = (int)max(sprframe->left * sprframe->left, sprframe->right * sprframe->right);
        y = (int)max(sprframe->up * sprframe->up, sprframe->down * sprframe->down);
        if (modelradius < x + y)
            modelradius = x + y;
    }
 
    if (cls.state != ca_dedicated)
    {
        for (i = 0;i < loadmodel->numframes;i++)
        {
            const dsprite2frame_t *pinframe;
            pinframe = &pinqsprite->frames[i];
            if (!(skinframe = R_SkinFrame_LoadExternal(pinframe->name, texflags, false, false)))
            {
                Con_Printf(CON_ERROR "Mod_IDS2_Load: failed to load %s", pinframe->name);
                skinframe = R_SkinFrame_LoadMissing();
            }
            Mod_SpriteSetupTexture(&loadmodel->data_textures[i], skinframe, fullbright, false);
        }
    }
 
    modelradius = sqrt(modelradius);
    for (i = 0;i < 3;i++)
    {
        loadmodel->normalmins[i] = loadmodel->yawmins[i] = loadmodel->rotatedmins[i] = -modelradius;
        loadmodel->normalmaxs[i] = loadmodel->yawmaxs[i] = loadmodel->rotatedmaxs[i] = modelradius;
    }
    loadmodel->radius = modelradius;
    loadmodel->radius2 = modelradius * modelradius;
 
    // TODO: Note that isanimated only means whether vertices change due to
    // the animation. This may happen due to sprframe parameters changing.
    // Mere texture chanegs OTOH shouldn't require isanimated to be 1.
    loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || (loadmodel->animscenes && loadmodel->animscenes[0].framecount > 1);
}

References model_t::animscenes, buffer, ca_dedicated, cls, CON_ERROR, Con_Printf(), model_t::data_textures, mspriteframe_t::down, dpsnprintf(), model_t::Draw, model_t::DrawDepth, model_t::DrawLight, animscene_t::firstframe, animscene_t::framecount, animscene_t::framerate, dsprite2_t::frames, dsprite2frame_t::height, height, Host_Error(), i, int(), cvar_t::integer, surfmesh_t::isanimated, mspriteframe_t::left, LittleLong, loadmodel, animscene_t::loop, max, MAX_QPATH, Mem_Alloc, model_t::mempool, mod_sprite, Mod_SpriteSetupTexture(), model_t::modeldatatypestring, animscene_t::name, dsprite2frame_t::name, model_t::name, model_t::normalmaxs, model_t::normalmins, NULL, model_t::num_textures, model_t::num_texturesperskin, dsprite2_t::numframes, model_t::numframes, origin, dsprite2frame_t::origin_x, dsprite2frame_t::origin_y, r_mipsprites, R_Model_Sprite_Draw(), R_SkinFrame_LoadExternal(), R_SkinFrame_LoadMissing(), model_t::radius, model_t::radius2, mspriteframe_t::right, model_t::rotatedmaxs, model_t::rotatedmins, SPR_VP_PARALLEL, model_sprite_t::sprdata_frames, model_t::sprite, SPRITE2_VERSION, model_sprite_t::sprnum_type, sqrt(), ST_SYNC, client_static_t::state, model_t::surfmesh, model_t::synctype, TEXF_ALPHA, TEXF_CLAMP, TEXF_COMPRESS, TEXF_ISSPRITE, TEXF_MIPMAP, TEXF_PICMIP, model_t::type, mspriteframe_t::up, dsprite2_t::version, version, dsprite2frame_t::width, width, x, y, model_t::yawmaxs, and model_t::yawmins.

Mod_IDSP_Load()

void Mod_IDSP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 267 of file model_sprite.c.

{
    int version;
    const unsigned char *datapointer;
 
    datapointer = (unsigned char *)buffer;
 
    loadmodel->modeldatatypestring = "SPR1";
 
    loadmodel->type = mod_sprite;
 
    loadmodel->Draw = R_Model_Sprite_Draw;
    loadmodel->DrawDepth = NULL;
    loadmodel->DrawLight = NULL;
 
    version = LittleLong(((dsprite_t *)buffer)->version);
    if (version == SPRITE_VERSION || version == SPRITE32_VERSION)
    {
        dsprite_t *pinqsprite;
 
        pinqsprite = (dsprite_t *)datapointer;
        datapointer += sizeof(dsprite_t);
 
        loadmodel->numframes = LittleLong (pinqsprite->numframes);
        loadmodel->sprite.sprnum_type = LittleLong (pinqsprite->type);
        loadmodel->synctype = (synctype_t)LittleLong (pinqsprite->synctype);
 
        Mod_Sprite_SharedSetup(datapointer, LittleLong (pinqsprite->version), NULL, false);
    }
    else if (version == SPRITEHL_VERSION)
    {
        int i, rendermode;
        unsigned char palette[256][4];
        const unsigned char *in;
        dspritehl_t *pinhlsprite;
 
        pinhlsprite = (dspritehl_t *)datapointer;
        datapointer += sizeof(dspritehl_t);
 
        loadmodel->numframes = LittleLong (pinhlsprite->numframes);
        loadmodel->sprite.sprnum_type = LittleLong (pinhlsprite->type);
        loadmodel->synctype = (synctype_t)LittleLong (pinhlsprite->synctype);
        rendermode = pinhlsprite->rendermode;
 
        in = datapointer;
        datapointer += 2;
        i = in[0] + in[1] * 256;
        if (i != 256)
            Host_Error ("Mod_IDSP_Load: unexpected number of palette colors %i (should be 256)", i);
        in = datapointer;
        datapointer += 768;
        switch(rendermode)
        {
        case SPRHL_OPAQUE:
            for (i = 0;i < 256;i++)
            {
                palette[i][2] = in[i*3+0];
                palette[i][1] = in[i*3+1];
                palette[i][0] = in[i*3+2];
                palette[i][3] = 255;
            }
            break;
        case SPRHL_ADDITIVE:
            for (i = 0;i < 256;i++)
            {
                palette[i][2] = in[i*3+0];
                palette[i][1] = in[i*3+1];
                palette[i][0] = in[i*3+2];
                palette[i][3] = 255;
            }
            // also passes additive == true to Mod_Sprite_SharedSetup
            break;
        case SPRHL_INDEXALPHA:
            for (i = 0;i < 256;i++)
            {
                palette[i][2] = in[765];
                palette[i][1] = in[766];
                palette[i][0] = in[767];
                palette[i][3] = i;
                in += 3;
            }
            break;
        case SPRHL_ALPHATEST:
            for (i = 0;i < 256;i++)
            {
                palette[i][2] = in[i*3+0];
                palette[i][1] = in[i*3+1];
                palette[i][0] = in[i*3+2];
                palette[i][3] = 255;
            }
            palette[255][0] = palette[255][1] = palette[255][2] = palette[255][3] = 0;
            // should this use alpha test or alpha blend?  (currently blend)
            break;
        default:
            Host_Error("Mod_IDSP_Load: unknown texFormat (%i, should be 0, 1, 2, or 3)", i);
            return;
        }
 
        Mod_Sprite_SharedSetup(datapointer, LittleLong (pinhlsprite->version), (unsigned int *)(&palette[0][0]), rendermode == SPRHL_ADDITIVE);
    }
    else
        Host_Error("Mod_IDSP_Load: %s has wrong version number (%i). Only %i (quake), %i (HalfLife), and %i (sprite32) supported",
                    loadmodel->name, version, SPRITE_VERSION, SPRITEHL_VERSION, SPRITE32_VERSION);
 
    // TODO: Note that isanimated only means whether vertices change due to
    // the animation. This may happen due to sprframe parameters changing.
    // Mere texture chanegs OTOH shouldn't require isanimated to be 1.
    loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || (loadmodel->animscenes && loadmodel->animscenes[0].framecount > 1);
}

References model_t::animscenes, buffer, model_t::Draw, model_t::DrawDepth, model_t::DrawLight, animscene_t::framecount, Host_Error(), i, surfmesh_t::isanimated, LittleLong, loadmodel, mod_sprite, Mod_Sprite_SharedSetup(), model_t::modeldatatypestring, model_t::name, NULL, dsprite_t::numframes, dspritehl_t::numframes, model_t::numframes, R_Model_Sprite_Draw(), dspritehl_t::rendermode, SPRHL_ADDITIVE, SPRHL_ALPHATEST, SPRHL_INDEXALPHA, SPRHL_OPAQUE, model_t::sprite, SPRITE32_VERSION, SPRITE_VERSION, SPRITEHL_VERSION, model_sprite_t::sprnum_type, model_t::surfmesh, dsprite_t::synctype, dspritehl_t::synctype, model_t::synctype, dsprite_t::type, dspritehl_t::type, model_t::type, dsprite_t::version, dspritehl_t::version, and version.

Mod_Init()

void Mod_Init

(

void

)

Definition at line 178 of file model_shared.c.

{
    mod_mempool = Mem_AllocPool("modelinfo", 0, NULL);
    Mem_ExpandableArray_NewArray(&models, mod_mempool, sizeof(model_t), 16);
 
    Mod_BrushInit();
    Mod_AliasInit();
    Mod_SpriteInit();
 
    Cvar_RegisterVariable(&r_mipskins);
    Cvar_RegisterVariable(&r_mipnormalmaps);
    Cvar_RegisterVariable(&mod_generatelightmaps_unitspersample);
    Cvar_RegisterVariable(&mod_generatelightmaps_borderpixels);
    Cvar_RegisterVariable(&mod_generatelightmaps_texturesize);
 
    Cvar_RegisterVariable(&mod_generatelightmaps_lightmapsamples);
    Cvar_RegisterVariable(&mod_generatelightmaps_vertexsamples);
    Cvar_RegisterVariable(&mod_generatelightmaps_gridsamples);
    Cvar_RegisterVariable(&mod_generatelightmaps_lightmapradius);
    Cvar_RegisterVariable(&mod_generatelightmaps_vertexradius);
    Cvar_RegisterVariable(&mod_generatelightmaps_gridradius);
 
    Cmd_AddCommand(CF_CLIENT, "modellist", Mod_Print_f, "prints a list of loaded models");
    Cmd_AddCommand(CF_CLIENT, "modelprecache", Mod_Precache_f, "load a model");
    Cmd_AddCommand(CF_CLIENT, "modeldecompile", Mod_Decompile_f, "exports a model in several formats for editing purposes");
    Cmd_AddCommand(CF_CLIENT, "mod_generatelightmaps", Mod_GenerateLightmaps_f, "rebuilds lighting on current worldmodel");
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), Mem_AllocPool, Mem_ExpandableArray_NewArray(), Mod_AliasInit(), Mod_BrushInit(), Mod_Decompile_f(), mod_generatelightmaps_borderpixels, Mod_GenerateLightmaps_f(), mod_generatelightmaps_gridradius, mod_generatelightmaps_gridsamples, mod_generatelightmaps_lightmapradius, mod_generatelightmaps_lightmapsamples, mod_generatelightmaps_texturesize, mod_generatelightmaps_unitspersample, mod_generatelightmaps_vertexradius, mod_generatelightmaps_vertexsamples, mod_mempool, Mod_Precache_f(), Mod_Print_f(), Mod_SpriteInit(), models, NULL, r_mipnormalmaps, and r_mipskins.

Referenced by Host_Init().

Mod_INTERQUAKEMODEL_Load()

void Mod_INTERQUAKEMODEL_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 3219 of file model_alias.c.

{
    unsigned char *data;
    const char *text;
    const unsigned char *pbase, *pend;
    iqmheader_t header;
    skinfile_t *skinfiles;
    int i, j, k;
    float biggestorigin;
    const unsigned int *inelements;
    int *outelements;
    float *outvertex, *outnormal, *outtexcoord, *outsvector, *outtvector, *outcolor;
    // this pointers into the file data are read only through Little* functions so they can be unaligned memory
    const float *vnormal = NULL;
    const float *vposition = NULL;
    const float *vtangent = NULL;
    const float *vtexcoord = NULL;
    const float *vcolor4f = NULL;
    const unsigned char *vblendindexes = NULL;
    const unsigned char *vblendweights = NULL;
    const unsigned char *vcolor4ub = NULL;
    const unsigned short *framedata = NULL;
    // temporary memory allocations (because the data in the file may be misaligned)
    iqmanim_t *anims = NULL;
    iqmbounds_t *bounds = NULL;
    iqmjoint1_t *joint1 = NULL;
    iqmjoint_t *joint = NULL;
    iqmmesh_t *meshes = NULL;
    iqmpose1_t *pose1 = NULL;
    iqmpose_t *pose = NULL;
    iqmvertexarray_t *vas = NULL;
 
    pbase = (unsigned char *)buffer;
    pend = (unsigned char *)bufferend;
 
    if (pbase + sizeof(iqmheader_t) > pend)
        Host_Error ("Mod_INTERQUAKEMODEL_Load: %s is not an Inter-Quake Model %d", loadmodel->name, (int)(pend - pbase));
 
    // copy struct (otherwise it may be misaligned)
    // LadyHavoc: okay it's definitely not misaligned here, but for consistency...
    memcpy(&header, pbase, sizeof(iqmheader_t));
 
    if (memcmp(header.id, "INTERQUAKEMODEL", 16))
        Host_Error ("Mod_INTERQUAKEMODEL_Load: %s is not an Inter-Quake Model", loadmodel->name);
    if (LittleLong(header.version) != 1 && LittleLong(header.version) != 2)
        Host_Error ("Mod_INTERQUAKEMODEL_Load: only version 1 and 2 models are currently supported (name = %s)", loadmodel->name);
 
    loadmodel->modeldatatypestring = "IQM";
 
    loadmodel->type = mod_alias;
    loadmodel->synctype = ST_RAND;
 
    // byteswap header
    header.version = LittleLong(header.version);
    header.filesize = LittleLong(header.filesize);
    header.flags = LittleLong(header.flags);
    header.num_text = LittleLong(header.num_text);
    header.ofs_text = LittleLong(header.ofs_text);
    header.num_meshes = LittleLong(header.num_meshes);
    header.ofs_meshes = LittleLong(header.ofs_meshes);
    header.num_vertexarrays = LittleLong(header.num_vertexarrays);
    header.num_vertexes = LittleLong(header.num_vertexes);
    header.ofs_vertexarrays = LittleLong(header.ofs_vertexarrays);
    header.num_triangles = LittleLong(header.num_triangles);
    header.ofs_triangles = LittleLong(header.ofs_triangles);
    header.ofs_neighbors = LittleLong(header.ofs_neighbors);
    header.num_joints = LittleLong(header.num_joints);
    header.ofs_joints = LittleLong(header.ofs_joints);
    header.num_poses = LittleLong(header.num_poses);
    header.ofs_poses = LittleLong(header.ofs_poses);
    header.num_anims = LittleLong(header.num_anims);
    header.ofs_anims = LittleLong(header.ofs_anims);
    header.num_frames = LittleLong(header.num_frames);
    header.num_framechannels = LittleLong(header.num_framechannels);
    header.ofs_frames = LittleLong(header.ofs_frames);
    header.ofs_bounds = LittleLong(header.ofs_bounds);
    header.num_comment = LittleLong(header.num_comment);
    header.ofs_comment = LittleLong(header.ofs_comment);
    header.num_extensions = LittleLong(header.num_extensions);
    header.ofs_extensions = LittleLong(header.ofs_extensions);
 
    if (header.version == 1)
    {
        if (pbase + header.ofs_joints + header.num_joints*sizeof(iqmjoint1_t) > pend ||
            pbase + header.ofs_poses + header.num_poses*sizeof(iqmpose1_t) > pend)
        {
            Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
            return;
        }
    }
    else
    {
        if (pbase + header.ofs_joints + header.num_joints*sizeof(iqmjoint_t) > pend ||
            pbase + header.ofs_poses + header.num_poses*sizeof(iqmpose_t) > pend)
        {
            Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
            return;
        }
    }
    if (pbase + header.ofs_text + header.num_text > pend ||
        pbase + header.ofs_meshes + header.num_meshes*sizeof(iqmmesh_t) > pend ||
        pbase + header.ofs_vertexarrays + header.num_vertexarrays*sizeof(iqmvertexarray_t) > pend ||
        pbase + header.ofs_triangles + header.num_triangles*sizeof(int[3]) > pend ||
        (header.ofs_neighbors && pbase + header.ofs_neighbors + header.num_triangles*sizeof(int[3]) > pend) ||
        pbase + header.ofs_anims + header.num_anims*sizeof(iqmanim_t) > pend ||
        pbase + header.ofs_frames + header.num_frames*header.num_framechannels*sizeof(unsigned short) > pend ||
        (header.ofs_bounds && pbase + header.ofs_bounds + header.num_frames*sizeof(iqmbounds_t) > pend) ||
        pbase + header.ofs_comment + header.num_comment > pend)
    {
        Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
        return;
    }
 
    // Structs will be copied for alignment in memory, otherwise we crash on Sparc, PowerPC and others
    // and get big spam from UBSan, because these offsets may not be aligned.
    if (header.num_vertexarrays)
        vas = (iqmvertexarray_t *)(pbase + header.ofs_vertexarrays);
    if (header.num_anims)
        anims = (iqmanim_t *)(pbase + header.ofs_anims);
    if (header.ofs_bounds)
        bounds = (iqmbounds_t *)(pbase + header.ofs_bounds);
    if (header.num_meshes)
        meshes = (iqmmesh_t *)(pbase + header.ofs_meshes);
 
    for (i = 0;i < (int)header.num_vertexarrays;i++)
    {
        iqmvertexarray_t va;
        size_t vsize;
 
        memcpy(&va, &vas[i], sizeof(iqmvertexarray_t));
        va.type = LittleLong(va.type);
        va.flags = LittleLong(va.flags);
        va.format = LittleLong(va.format);
        va.size = LittleLong(va.size);
        va.offset = LittleLong(va.offset);
        vsize = header.num_vertexes*va.size;
        switch (va.format)
        { 
        case IQM_FLOAT: vsize *= sizeof(float); break;
        case IQM_UBYTE: vsize *= sizeof(unsigned char); break;
        default: continue;
        }
        if (pbase + va.offset + vsize > pend)
            continue;
        // no need to copy the vertex data for alignment because LittleLong/LittleShort will be invoked on reading them, and the destination is aligned
        switch (va.type)
        {
        case IQM_POSITION:
            if (va.format == IQM_FLOAT && va.size == 3)
                vposition = (const float *)(pbase + va.offset);
            break;
        case IQM_TEXCOORD:
            if (va.format == IQM_FLOAT && va.size == 2)
                vtexcoord = (const float *)(pbase + va.offset);
            break;
        case IQM_NORMAL:
            if (va.format == IQM_FLOAT && va.size == 3)
                vnormal = (const float *)(pbase + va.offset);
            break;
        case IQM_TANGENT:
            if (va.format == IQM_FLOAT && va.size == 4)
                vtangent = (const float *)(pbase + va.offset);
            break;
        case IQM_BLENDINDEXES:
            if (va.format == IQM_UBYTE && va.size == 4)
                vblendindexes = (const unsigned char *)(pbase + va.offset);
            break;
        case IQM_BLENDWEIGHTS:
            if (va.format == IQM_UBYTE && va.size == 4)
                vblendweights = (const unsigned char *)(pbase + va.offset);
            break;
        case IQM_COLOR:
            if (va.format == IQM_FLOAT && va.size == 4)
                vcolor4f = (const float *)(pbase + va.offset);
            if (va.format == IQM_UBYTE && va.size == 4)
                vcolor4ub = (const unsigned char *)(pbase + va.offset);
            break;
        }
    }
    if (header.num_vertexes > 0 && (!vposition || !vtexcoord || ((header.num_frames > 0 || header.num_anims > 0) && (!vblendindexes || !vblendweights))))
    {
        Con_Printf("%s is missing vertex array data\n", loadmodel->name);
        return;
    }
 
    text = header.num_text && header.ofs_text ? (const char *)(pbase + header.ofs_text) : "";
 
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
 
    // load external .skin files if present
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
 
    loadmodel->numframes = max(header.num_anims, 1);
    loadmodel->num_bones = header.num_joints;
    loadmodel->num_poses = max(header.num_frames, 1);
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces = header.num_meshes;
    loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
    loadmodel->num_texturesperskin = loadmodel->num_surfaces;
    loadmodel->surfmesh.num_vertices = header.num_vertexes;
    loadmodel->surfmesh.num_triangles = header.num_triangles;
 
    // do most allocations as one merged chunk
    // This is only robust for C standard types!
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool,
        loadmodel->surfmesh.num_vertices * (sizeof(float[14]) + (vcolor4f || vcolor4ub ? sizeof(float[4]) : 0))
        + loadmodel->num_bones * sizeof(float[12])
        + loadmodel->num_surfaces * sizeof(int)
        + loadmodel->surfmesh.num_triangles * sizeof(int[3])
        + (loadmodel->surfmesh.num_vertices <= 65536 ? loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]) : 0)
        + loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7])
        + (vblendindexes && vblendweights ? loadmodel->surfmesh.num_vertices * (sizeof(unsigned short) + sizeof(unsigned char[2][4])) : 0));
    // Pointers must be taken in descending order of alignment requirement!
    loadmodel->surfmesh.data_vertex3f          = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_svector3f         = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_tvector3f         = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_normal3f          = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
    if (vcolor4f || vcolor4ub)
    {
        loadmodel->surfmesh.data_lightmapcolor4f = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
    }
    loadmodel->data_baseboneposeinverse = (float *)data; data += loadmodel->num_bones * sizeof(float[12]);
    loadmodel->modelsurfaces_sorted       = (int *)data; data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->surfmesh.data_element3i    = (int *)data; data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
    loadmodel->data_poses7s             = (short *)data; data += loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]);
    if (loadmodel->surfmesh.num_vertices <= 65536)
    {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data; data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
    }
    if (vblendindexes && vblendweights)
    {
        loadmodel->surfmesh.num_blends = 0;
        loadmodel->surfmesh.blends                = (unsigned short *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned short);
        loadmodel->surfmesh.data_skeletalindex4ub  = (unsigned char *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
        loadmodel->surfmesh.data_skeletalweight4ub = (unsigned char *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
    }
    // Struct alignment requirements could change so we can't assume them here
    // otherwise a safe-looking commit could introduce undefined behaviour!
    loadmodel->data_surfaces = Mem_AllocType(loadmodel->mempool, msurface_t, loadmodel->num_surfaces * sizeof(msurface_t));
    loadmodel->data_textures = Mem_AllocType(loadmodel->mempool, texture_t, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
    loadmodel->skinscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numskins * sizeof(animscene_t));
    loadmodel->data_bones = Mem_AllocType(loadmodel->mempool, aliasbone_t, loadmodel->num_bones * sizeof(aliasbone_t));
    loadmodel->animscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numframes * sizeof(animscene_t));
    if (vblendindexes && vblendweights)
        loadmodel->surfmesh.data_blendweights = Mem_AllocType(loadmodel->mempool, blendweights_t, loadmodel->surfmesh.num_vertices * sizeof(blendweights_t));
 
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // load the bone info
    if (header.version == 1)
    {
        iqmjoint1_t *injoints1 = (iqmjoint1_t *)(pbase + header.ofs_joints);
 
        if (loadmodel->num_bones)
            joint1 = (iqmjoint1_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_bones * sizeof(iqmjoint1_t));
        for (i = 0;i < loadmodel->num_bones;i++)
        {
            matrix4x4_t relbase, relinvbase, pinvbase, invbase;
            iqmjoint1_t injoint1;
 
            memcpy(&injoint1, &injoints1[i], sizeof(iqmjoint1_t));
            joint1[i].name = LittleLong(injoint1.name);
            joint1[i].parent = LittleLong(injoint1.parent);
            for (j = 0;j < 3;j++)
            {
                joint1[i].origin[j] = LittleFloat(injoint1.origin[j]);
                joint1[i].rotation[j] = LittleFloat(injoint1.rotation[j]);
                joint1[i].scale[j] = LittleFloat(injoint1.scale[j]);
            }
            dp_strlcpy(loadmodel->data_bones[i].name, &text[joint1[i].name], sizeof(loadmodel->data_bones[i].name));
            loadmodel->data_bones[i].parent = joint1[i].parent;
            if (loadmodel->data_bones[i].parent >= i)
                Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
            Matrix4x4_FromDoom3Joint(&relbase, joint1[i].origin[0], joint1[i].origin[1], joint1[i].origin[2], joint1[i].rotation[0], joint1[i].rotation[1], joint1[i].rotation[2]);
            Matrix4x4_Invert_Simple(&relinvbase, &relbase);
            if (loadmodel->data_bones[i].parent >= 0)
            {
                Matrix4x4_FromArray12FloatD3D(&pinvbase, loadmodel->data_baseboneposeinverse + 12*loadmodel->data_bones[i].parent);
                Matrix4x4_Concat(&invbase, &relinvbase, &pinvbase);
                Matrix4x4_ToArray12FloatD3D(&invbase, loadmodel->data_baseboneposeinverse + 12*i);
            }
            else Matrix4x4_ToArray12FloatD3D(&relinvbase, loadmodel->data_baseboneposeinverse + 12*i);
        }
    }
    else
    {
        iqmjoint_t *injoints = (iqmjoint_t *)(pbase + header.ofs_joints);
 
        if (header.num_joints)
            joint = (iqmjoint_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_bones * sizeof(iqmjoint_t));
        for (i = 0;i < loadmodel->num_bones;i++)
        {
            matrix4x4_t relbase, relinvbase, pinvbase, invbase;
            iqmjoint_t injoint;
 
            memcpy(&injoint, &injoints[i], sizeof(iqmjoint_t));
            joint[i].name = LittleLong(injoint.name);
            joint[i].parent = LittleLong(injoint.parent);
            for (j = 0;j < 3;j++)
            {
                joint[i].origin[j] = LittleFloat(injoint.origin[j]);
                joint[i].rotation[j] = LittleFloat(injoint.rotation[j]);
                joint[i].scale[j] = LittleFloat(injoint.scale[j]);
            }
            joint[i].rotation[3] = LittleFloat(injoint.rotation[3]);
            dp_strlcpy(loadmodel->data_bones[i].name, &text[joint[i].name], sizeof(loadmodel->data_bones[i].name));
            loadmodel->data_bones[i].parent = joint[i].parent;
            if (loadmodel->data_bones[i].parent >= i)
                Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
            if (joint[i].rotation[3] > 0)
                Vector4Negate(joint[i].rotation, joint[i].rotation);
            Vector4Normalize2(joint[i].rotation, joint[i].rotation);
            Matrix4x4_FromDoom3Joint(&relbase, joint[i].origin[0], joint[i].origin[1], joint[i].origin[2], joint[i].rotation[0], joint[i].rotation[1], joint[i].rotation[2]);
            Matrix4x4_Invert_Simple(&relinvbase, &relbase);
            if (loadmodel->data_bones[i].parent >= 0)
            {
                Matrix4x4_FromArray12FloatD3D(&pinvbase, loadmodel->data_baseboneposeinverse + 12*loadmodel->data_bones[i].parent);
                Matrix4x4_Concat(&invbase, &relinvbase, &pinvbase);
                Matrix4x4_ToArray12FloatD3D(&invbase, loadmodel->data_baseboneposeinverse + 12*i);
            }   
            else Matrix4x4_ToArray12FloatD3D(&relinvbase, loadmodel->data_baseboneposeinverse + 12*i);
        }
    }
 
    // set up the animscenes based on the anims
    for (i = 0;i < (int)header.num_anims;i++)
    {
        iqmanim_t anim;
 
        memcpy(&anim, &anims[i], sizeof(iqmanim_t));
        anim.name = LittleLong(anim.name);
        anim.first_frame = LittleLong(anim.first_frame);
        anim.num_frames = LittleLong(anim.num_frames);
        anim.framerate = LittleFloat(anim.framerate);
        anim.flags = LittleLong(anim.flags);
        dp_strlcpy(loadmodel->animscenes[i].name, &text[anim.name], sizeof(loadmodel->animscenes[i].name));
        loadmodel->animscenes[i].firstframe = anim.first_frame;
        loadmodel->animscenes[i].framecount = anim.num_frames;
        loadmodel->animscenes[i].loop = ((anim.flags & IQM_LOOP) != 0);
        loadmodel->animscenes[i].framerate = anim.framerate;
    }
    if (header.num_anims <= 0)
    {
        dp_strlcpy(loadmodel->animscenes[0].name, "static", sizeof(loadmodel->animscenes[0].name));
        loadmodel->animscenes[0].firstframe = 0;
        loadmodel->animscenes[0].framecount = 1;
        loadmodel->animscenes[0].loop = true;
        loadmodel->animscenes[0].framerate = 10;
    }
 
    loadmodel->surfmesh.isanimated = loadmodel->num_bones > 1 || loadmodel->numframes > 1 || (loadmodel->animscenes && loadmodel->animscenes[0].framecount > 1);
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    biggestorigin = 0;
    if (header.version == 1)
    {
        iqmpose1_t *inposes1 = (iqmpose1_t *)(pbase + header.ofs_poses);
 
        if (header.num_poses)
            pose1 = (iqmpose1_t *)Mem_Alloc(loadmodel->mempool, header.num_poses * sizeof(iqmpose1_t));
        for (i = 0;i < (int)header.num_poses;i++)
        {
            float f;
            iqmpose1_t inpose;
 
            memcpy(&inpose, &inposes1[i], sizeof(iqmpose1_t));
            pose1[i].parent = LittleLong(inpose.parent);
            pose1[i].channelmask = LittleLong(inpose.channelmask);
            for (j = 0;j < 9;j++)
            {
                pose1[i].channeloffset[j] = LittleFloat(inpose.channeloffset[j]);
                pose1[i].channelscale[j] = LittleFloat(inpose.channelscale[j]);
            }
            f = fabs(pose1[i].channeloffset[0]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose1[i].channeloffset[1]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose1[i].channeloffset[2]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose1[i].channeloffset[0] + 0xFFFF*pose1[i].channelscale[0]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose1[i].channeloffset[1] + 0xFFFF*pose1[i].channelscale[1]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose1[i].channeloffset[2] + 0xFFFF*pose1[i].channelscale[2]); biggestorigin = max(biggestorigin, f);
        }
        if (header.num_frames <= 0)
        {
            for (i = 0;i < loadmodel->num_bones;i++)
            {
                float f;
                f = fabs(joint1[i].origin[0]); biggestorigin = max(biggestorigin, f);
                f = fabs(joint1[i].origin[1]); biggestorigin = max(biggestorigin, f);
                f = fabs(joint1[i].origin[2]); biggestorigin = max(biggestorigin, f);
            }
        }
    }
    else
    {
        iqmpose_t *inposes = (iqmpose_t *)(pbase + header.ofs_poses);
 
        if (header.num_poses)
            pose = (iqmpose_t *)Mem_Alloc(loadmodel->mempool, header.num_poses * sizeof(iqmpose_t));
        for (i = 0;i < (int)header.num_poses;i++)
        {
            float f;
            iqmpose_t inpose;
 
            memcpy(&inpose, &inposes[i], sizeof(iqmpose_t));
            pose[i].parent = LittleLong(inpose.parent);
            pose[i].channelmask = LittleLong(inpose.channelmask);
            for (j = 0;j < 10;j++)
            {
                pose[i].channeloffset[j] = LittleFloat(inpose.channeloffset[j]);
                pose[i].channelscale[j] = LittleFloat(inpose.channelscale[j]);
            }
            f = fabs(pose[i].channeloffset[0]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose[i].channeloffset[1]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose[i].channeloffset[2]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose[i].channeloffset[0] + 0xFFFF*pose[i].channelscale[0]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose[i].channeloffset[1] + 0xFFFF*pose[i].channelscale[1]); biggestorigin = max(biggestorigin, f);
            f = fabs(pose[i].channeloffset[2] + 0xFFFF*pose[i].channelscale[2]); biggestorigin = max(biggestorigin, f);
        }
        if (header.num_frames <= 0)
        {
            for (i = 0;i < loadmodel->num_bones;i++)
            {
                float f;
                f = fabs(joint[i].origin[0]); biggestorigin = max(biggestorigin, f);
                f = fabs(joint[i].origin[1]); biggestorigin = max(biggestorigin, f);
                f = fabs(joint[i].origin[2]); biggestorigin = max(biggestorigin, f);
            }
        }
    }
    loadmodel->num_posescale = biggestorigin / 32767.0f;
    loadmodel->num_poseinvscale = 1.0f / loadmodel->num_posescale;
 
    // load the pose data
    // this unaligned memory access is safe (LittleShort reads as bytes)
    framedata = (const unsigned short *)(pbase + header.ofs_frames);
    if (header.version == 1)
    {
        for (i = 0, k = 0;i < (int)header.num_frames;i++)
        {
            for (j = 0;j < (int)header.num_poses;j++, k++)
            {
                float qx, qy, qz, qw;
                loadmodel->data_poses7s[k*7 + 0] = loadmodel->num_poseinvscale * (pose1[j].channeloffset[0] + (pose1[j].channelmask&1 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[0] : 0));
                loadmodel->data_poses7s[k*7 + 1] = loadmodel->num_poseinvscale * (pose1[j].channeloffset[1] + (pose1[j].channelmask&2 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[1] : 0));
                loadmodel->data_poses7s[k*7 + 2] = loadmodel->num_poseinvscale * (pose1[j].channeloffset[2] + (pose1[j].channelmask&4 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[2] : 0));
                qx = pose1[j].channeloffset[3] + (pose1[j].channelmask&8 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[3] : 0);
                qy = pose1[j].channeloffset[4] + (pose1[j].channelmask&16 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[4] : 0);
                qz = pose1[j].channeloffset[5] + (pose1[j].channelmask&32 ? (unsigned short)LittleShort(*framedata++) * pose1[j].channelscale[5] : 0);
                qw = 1.0f - (qx*qx + qy*qy + qz*qz);
                qw = qw > 0.0f ? -sqrt(qw) : 0.0f;
                loadmodel->data_poses7s[k*7 + 3] = 32767.0f * qx;
                loadmodel->data_poses7s[k*7 + 4] = 32767.0f * qy;
                loadmodel->data_poses7s[k*7 + 5] = 32767.0f * qz;
                loadmodel->data_poses7s[k*7 + 6] = 32767.0f * qw;
                // skip scale data for now
                if(pose1[j].channelmask&64) framedata++;
                if(pose1[j].channelmask&128) framedata++;
                if(pose1[j].channelmask&256) framedata++;
            }
        }
        if (header.num_frames <= 0)
        {
            for (i = 0;i < loadmodel->num_bones;i++)
            {
                float qx, qy, qz, qw;
                loadmodel->data_poses7s[i*7 + 0] = loadmodel->num_poseinvscale * joint1[i].origin[0];
                loadmodel->data_poses7s[i*7 + 1] = loadmodel->num_poseinvscale * joint1[i].origin[1];
                loadmodel->data_poses7s[i*7 + 2] = loadmodel->num_poseinvscale * joint1[i].origin[2];
                qx = joint1[i].rotation[0];
                qy = joint1[i].rotation[1];
                qz = joint1[i].rotation[2];
                qw = 1.0f - (qx*qx + qy*qy + qz*qz);
                qw = qw > 0.0f ? -sqrt(qw) : 0.0f;
                loadmodel->data_poses7s[i*7 + 3] = 32767.0f * qx;
                loadmodel->data_poses7s[i*7 + 4] = 32767.0f * qy;
                loadmodel->data_poses7s[i*7 + 5] = 32767.0f * qz;
                loadmodel->data_poses7s[i*7 + 6] = 32767.0f * qw;
            }
        }
    }
    else
    {
        for (i = 0, k = 0;i < (int)header.num_frames;i++)   
        {
            for (j = 0;j < (int)header.num_poses;j++, k++)
            {
                float rot[4];
                loadmodel->data_poses7s[k*7 + 0] = loadmodel->num_poseinvscale * (pose[j].channeloffset[0] + (pose[j].channelmask&1 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[0] : 0));
                loadmodel->data_poses7s[k*7 + 1] = loadmodel->num_poseinvscale * (pose[j].channeloffset[1] + (pose[j].channelmask&2 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[1] : 0));
                loadmodel->data_poses7s[k*7 + 2] = loadmodel->num_poseinvscale * (pose[j].channeloffset[2] + (pose[j].channelmask&4 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[2] : 0));
                rot[0] = pose[j].channeloffset[3] + (pose[j].channelmask&8 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[3] : 0);
                rot[1] = pose[j].channeloffset[4] + (pose[j].channelmask&16 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[4] : 0);
                rot[2] = pose[j].channeloffset[5] + (pose[j].channelmask&32 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[5] : 0);
                rot[3] = pose[j].channeloffset[6] + (pose[j].channelmask&64 ? (unsigned short)LittleShort(*framedata++) * pose[j].channelscale[6] : 0);
                if (rot[3] > 0)
                    Vector4Negate(rot, rot);
                Vector4Normalize2(rot, rot);
                loadmodel->data_poses7s[k*7 + 3] = 32767.0f * rot[0];
                loadmodel->data_poses7s[k*7 + 4] = 32767.0f * rot[1];
                loadmodel->data_poses7s[k*7 + 5] = 32767.0f * rot[2];
                loadmodel->data_poses7s[k*7 + 6] = 32767.0f * rot[3];
                // skip scale data for now
                if(pose[j].channelmask&128) framedata++;
                if(pose[j].channelmask&256) framedata++;
                if(pose[j].channelmask&512) framedata++;
            }
        }
        if (header.num_frames <= 0)
        {
            for (i = 0;i < loadmodel->num_bones;i++)
            {
                loadmodel->data_poses7s[i*7 + 0] = loadmodel->num_poseinvscale * joint[i].origin[0];
                loadmodel->data_poses7s[i*7 + 1] = loadmodel->num_poseinvscale * joint[i].origin[1];
                loadmodel->data_poses7s[i*7 + 2] = loadmodel->num_poseinvscale * joint[i].origin[2];
                loadmodel->data_poses7s[i*7 + 3] = 32767.0f * joint[i].rotation[0];
                loadmodel->data_poses7s[i*7 + 4] = 32767.0f * joint[i].rotation[1];
                loadmodel->data_poses7s[i*7 + 5] = 32767.0f * joint[i].rotation[2];
                loadmodel->data_poses7s[i*7 + 6] = 32767.0f * joint[i].rotation[3];
            }
        }
    }
 
    // load bounding box data
    if (header.ofs_bounds)
    {
        float xyradius = 0, radius = 0;
        VectorClear(loadmodel->normalmins);
        VectorClear(loadmodel->normalmaxs);
        for (i = 0; i < (int)header.num_frames;i++)
        {
            iqmbounds_t bound;
            bound.mins[0] = LittleFloat(bounds[i].mins[0]);
            bound.mins[1] = LittleFloat(bounds[i].mins[1]);
            bound.mins[2] = LittleFloat(bounds[i].mins[2]);
            bound.maxs[0] = LittleFloat(bounds[i].maxs[0]);         
            bound.maxs[1] = LittleFloat(bounds[i].maxs[1]); 
            bound.maxs[2] = LittleFloat(bounds[i].maxs[2]); 
            bound.xyradius = LittleFloat(bounds[i].xyradius);
            bound.radius = LittleFloat(bounds[i].radius);
            if (!i)
            {
                VectorCopy(bound.mins, loadmodel->normalmins);
                VectorCopy(bound.maxs, loadmodel->normalmaxs);
            }
            else
            {
                if (loadmodel->normalmins[0] > bound.mins[0]) loadmodel->normalmins[0] = bound.mins[0];
                if (loadmodel->normalmins[1] > bound.mins[1]) loadmodel->normalmins[1] = bound.mins[1];
                if (loadmodel->normalmins[2] > bound.mins[2]) loadmodel->normalmins[2] = bound.mins[2];
                if (loadmodel->normalmaxs[0] < bound.maxs[0]) loadmodel->normalmaxs[0] = bound.maxs[0];
                if (loadmodel->normalmaxs[1] < bound.maxs[1]) loadmodel->normalmaxs[1] = bound.maxs[1];
                if (loadmodel->normalmaxs[2] < bound.maxs[2]) loadmodel->normalmaxs[2] = bound.maxs[2];
            }
            if (bound.xyradius > xyradius)
                xyradius = bound.xyradius;
            if (bound.radius > radius)
                radius = bound.radius;
        }
        loadmodel->yawmins[0] = loadmodel->yawmins[1] = -xyradius;
        loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = xyradius;
        loadmodel->yawmins[2] = loadmodel->normalmins[2];
        loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
        loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -radius;
        loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = radius;
        loadmodel->radius = radius;
        loadmodel->radius2 = radius * radius;
    }
 
    // load triangle data
    // this unaligned memory access is safe (LittleLong reads as bytes)
    inelements = (const unsigned int *)(pbase + header.ofs_triangles);
    outelements = loadmodel->surfmesh.data_element3i;
    for (i = 0;i < (int)header.num_triangles;i++)
    {
        outelements[0] = LittleLong(inelements[0]);
        outelements[1] = LittleLong(inelements[1]);
        outelements[2] = LittleLong(inelements[2]);
        outelements += 3;
        inelements += 3;
    }
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
    Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, header.num_vertexes, __FILE__, __LINE__);
 
    // load vertex data
    // this unaligned memory access is safe (LittleFloat reads as bytes)
    outvertex = loadmodel->surfmesh.data_vertex3f;
    for (i = 0;i < (int)header.num_vertexes;i++)
    {
        outvertex[0] = LittleFloat(vposition[0]);
        outvertex[1] = LittleFloat(vposition[1]);
        outvertex[2] = LittleFloat(vposition[2]);
        vposition += 3;
        outvertex += 3;
    }
 
    outtexcoord = loadmodel->surfmesh.data_texcoordtexture2f;
    // this unaligned memory access is safe (LittleFloat reads as bytes)
    for (i = 0;i < (int)header.num_vertexes;i++)
    {
        outtexcoord[0] = LittleFloat(vtexcoord[0]);
        outtexcoord[1] = LittleFloat(vtexcoord[1]);
        vtexcoord += 2;
        outtexcoord += 2;
    }
 
    // this unaligned memory access is safe (LittleFloat reads as bytes)
    if(vnormal)
    {
        outnormal = loadmodel->surfmesh.data_normal3f;
        for (i = 0;i < (int)header.num_vertexes;i++)
        {
            outnormal[0] = LittleFloat(vnormal[0]);
            outnormal[1] = LittleFloat(vnormal[1]);
            outnormal[2] = LittleFloat(vnormal[2]);
            vnormal += 3;
            outnormal += 3;
        }
    }
 
    // this unaligned memory access is safe (LittleFloat reads as bytes)
    if(vnormal && vtangent)
    {
        outnormal = loadmodel->surfmesh.data_normal3f;
        outsvector = loadmodel->surfmesh.data_svector3f;
        outtvector = loadmodel->surfmesh.data_tvector3f;
        for (i = 0;i < (int)header.num_vertexes;i++)
        {
            outsvector[0] = LittleFloat(vtangent[0]);
            outsvector[1] = LittleFloat(vtangent[1]);
            outsvector[2] = LittleFloat(vtangent[2]);
            if(LittleFloat(vtangent[3]) < 0)
                CrossProduct(outsvector, outnormal, outtvector);
            else
                CrossProduct(outnormal, outsvector, outtvector);
            vtangent += 4;
            outnormal += 3;
            outsvector += 3;
            outtvector += 3;
        }
    }
 
    // this unaligned memory access is safe (all bytes)
    if (vblendindexes && vblendweights)
    {
        for (i = 0; i < (int)header.num_vertexes;i++)
        {
            blendweights_t weights;
            memcpy(weights.index, vblendindexes + i*4, 4);
            memcpy(weights.influence, vblendweights + i*4, 4);
            loadmodel->surfmesh.blends[i] = Mod_Skeletal_AddBlend(loadmodel, &weights);
            loadmodel->surfmesh.data_skeletalindex4ub[i*4  ] = weights.index[0];
            loadmodel->surfmesh.data_skeletalindex4ub[i*4+1] = weights.index[1];
            loadmodel->surfmesh.data_skeletalindex4ub[i*4+2] = weights.index[2];
            loadmodel->surfmesh.data_skeletalindex4ub[i*4+3] = weights.index[3];
            loadmodel->surfmesh.data_skeletalweight4ub[i*4  ] = weights.influence[0];
            loadmodel->surfmesh.data_skeletalweight4ub[i*4+1] = weights.influence[1];
            loadmodel->surfmesh.data_skeletalweight4ub[i*4+2] = weights.influence[2];
            loadmodel->surfmesh.data_skeletalweight4ub[i*4+3] = weights.influence[3];
        }
    }
 
    if (vcolor4f)
    {
        outcolor = loadmodel->surfmesh.data_lightmapcolor4f;
        // this unaligned memory access is safe (LittleFloat reads as bytes)
        for (i = 0;i < (int)header.num_vertexes;i++)
        {
            outcolor[0] = LittleFloat(vcolor4f[0]);
            outcolor[1] = LittleFloat(vcolor4f[1]);
            outcolor[2] = LittleFloat(vcolor4f[2]);
            outcolor[3] = LittleFloat(vcolor4f[3]);
            vcolor4f += 4;
            outcolor += 4;
        }
    }
    else if (vcolor4ub)
    {
        outcolor = loadmodel->surfmesh.data_lightmapcolor4f;
        // this unaligned memory access is safe (all bytes)
        for (i = 0;i < (int)header.num_vertexes;i++)
        {
            outcolor[0] = vcolor4ub[0] * (1.0f / 255.0f);
            outcolor[1] = vcolor4ub[1] * (1.0f / 255.0f);
            outcolor[2] = vcolor4ub[2] * (1.0f / 255.0f);
            outcolor[3] = vcolor4ub[3] * (1.0f / 255.0f);
            vcolor4ub += 4;
            outcolor += 4;
        }
    }
 
    // load meshes
    for (i = 0;i < (int)header.num_meshes;i++)
    {
        iqmmesh_t mesh;
        msurface_t *surface;
 
        memcpy(&mesh, &meshes[i], sizeof(iqmmesh_t));
        mesh.name = LittleLong(mesh.name);
        mesh.material = LittleLong(mesh.material);
        mesh.first_vertex = LittleLong(mesh.first_vertex);
        mesh.num_vertexes = LittleLong(mesh.num_vertexes);
        mesh.first_triangle = LittleLong(mesh.first_triangle);
        mesh.num_triangles = LittleLong(mesh.num_triangles);
 
        loadmodel->modelsurfaces_sorted[i] = i;
        surface = loadmodel->data_surfaces + i;
        surface->texture = loadmodel->data_textures + i;
        surface->num_firsttriangle = mesh.first_triangle;
        surface->num_triangles = mesh.num_triangles;
        surface->num_firstvertex = mesh.first_vertex;
        surface->num_vertices = mesh.num_vertexes;
 
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + i, skinfiles, &text[mesh.name], &text[mesh.material]);
    }
 
    Mod_FreeSkinFiles(skinfiles);
    Mod_MakeSortedSurfaces(loadmodel);
 
    // compute all the mesh information that was not loaded from the file
    if (!vnormal)
        Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0);
    if (!vnormal || !vtangent)
        Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0);
    if (!header.ofs_bounds)
        Mod_Alias_CalculateBoundingBox();
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
 
    if (joint)  { Mem_Free(joint);  joint  = NULL; }
    if (joint1) { Mem_Free(joint1); joint1 = NULL; }
    if (pose)   { Mem_Free(pose);   pose   = NULL; }
    if (pose1)  { Mem_Free(pose1);  pose1  = NULL; }
}

References model_t::AnimateVertices, model_t::animscenes, surfmesh_t::blends, bound, buffer, iqmpose1_t::channelmask, iqmpose_t::channelmask, iqmpose1_t::channeloffset, iqmpose_t::channeloffset, iqmpose1_t::channelscale, iqmpose_t::channelscale, model_t::collision_bih, model_t::CompileShadowMap, Con_Printf(), CrossProduct, data, model_t::data_baseboneposeinverse, surfmesh_t::data_blendweights, model_t::data_bones, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_lightmapcolor4f, surfmesh_t::data_normal3f, model_t::data_poses7s, surfmesh_t::data_skeletalindex4ub, surfmesh_t::data_skeletalweight4ub, model_t::data_surfaces, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, dp_strlcpy, model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, f, fabs(), iqmheader_t::filesize, iqmanim_t::first_frame, iqmmesh_t::first_triangle, iqmmesh_t::first_vertex, animscene_t::firstframe, iqmanim_t::flags, iqmheader_t::flags, float, animscene_t::framecount, animscene_t::framerate, iqmanim_t::framerate, Host_Error(), i, iqmheader_t::id, blendweights_t::index, blendweights_t::influence, int(), cvar_t::integer, IQM_BLENDINDEXES, IQM_BLENDWEIGHTS, IQM_COLOR, IQM_FLOAT, IQM_LOOP, IQM_NORMAL, IQM_POSITION, IQM_TANGENT, IQM_TEXCOORD, IQM_UBYTE, surfmesh_t::isanimated, LittleFloat, LittleLong, LittleShort, loadmodel, animscene_t::loop, iqmmesh_t::material, Matrix4x4_Concat(), Matrix4x4_FromArray12FloatD3D(), Matrix4x4_FromDoom3Joint(), Matrix4x4_Invert_Simple(), Matrix4x4_ToArray12FloatD3D(), max, maxs, Mem_Alloc, Mem_AllocType, Mem_Free, model_t::mempool, iqmbounds_t::mins, mins, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildNormals(), Mod_BuildTextureVectorsFromNormals(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_Skeletal_AddBlend(), Mod_Skeletal_AnimateVertices(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, aliasbone_t::name, animscene_t::name, iqmanim_t::name, iqmjoint1_t::name, iqmjoint_t::name, iqmmesh_t::name, model_t::name, model_t::normalmaxs, model_t::normalmins, NULL, iqmheader_t::num_anims, surfmesh_t::num_blends, model_t::num_bones, iqmheader_t::num_comment, iqmheader_t::num_extensions, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, iqmheader_t::num_framechannels, iqmanim_t::num_frames, iqmheader_t::num_frames, iqmheader_t::num_joints, iqmheader_t::num_meshes, model_t::num_poseinvscale, iqmheader_t::num_poses, model_t::num_poses, model_t::num_posescale, model_t::num_surfaces, iqmheader_t::num_text, model_t::num_textures, model_t::num_texturesperskin, iqmheader_t::num_triangles, iqmmesh_t::num_triangles, msurface_t::num_triangles, surfmesh_t::num_triangles, iqmheader_t::num_vertexarrays, iqmheader_t::num_vertexes, iqmmesh_t::num_vertexes, msurface_t::num_vertices, surfmesh_t::num_vertices, model_t::numframes, model_t::numskins, iqmheader_t::ofs_anims, iqmheader_t::ofs_bounds, iqmheader_t::ofs_comment, iqmheader_t::ofs_extensions, iqmheader_t::ofs_frames, iqmheader_t::ofs_joints, iqmheader_t::ofs_meshes, iqmheader_t::ofs_neighbors, iqmheader_t::ofs_poses, iqmheader_t::ofs_text, iqmheader_t::ofs_triangles, iqmheader_t::ofs_vertexarrays, iqmjoint1_t::origin, iqmjoint_t::origin, origin, aliasbone_t::parent, iqmjoint1_t::parent, iqmjoint_t::parent, iqmpose1_t::parent, iqmpose_t::parent, model_t::PointSuperContents, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), r_smoothnormals_areaweighting, model_t::radius, model_t::radius2, model_t::rotatedmaxs, model_t::rotatedmins, iqmjoint1_t::rotation, iqmjoint_t::rotation, iqmjoint1_t::scale, iqmjoint_t::scale, model_t::skinscenes, sqrt(), ST_RAND, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, model_t::surfmesh, model_t::synctype, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, model_t::type, va(), Vector4Negate, Vector4Normalize2, VectorClear, VectorCopy, iqmheader_t::version, model_t::yawmaxs, and model_t::yawmins.

Mod_LoadCustomMaterial()

void Mod_LoadCustomMaterial	(	struct mempool_s *	mempool,
		texture_t *	texture,
		const char *	name,
		int	supercontents,
		int	materialflags,
		struct skinframe_s *	skinframe )

Sets up a material to render the provided skinframe. See also R_SkinFrame_LoadInternalBGRA.

Mod_LoadModel()

model_t * Mod_LoadModel	(	model_t *	mod,
		qbool	crash,
		qbool	checkdisk )

Definition at line 406 of file model_shared.c.

{
    unsigned int crc;
    void *buf;
    fs_offset_t filesize = 0;
    char vabuf[1024];
 
    mod->used = true;
 
    if (mod->name[0] == '*') // submodel
        return mod;
    
    if (!strcmp(mod->name, "null"))
    {
        if(mod->loaded)
            return mod;
 
        if (mod->loaded || mod->mempool)
            Mod_UnloadModel(mod);
 
        if (developer_loading.integer)
            Con_Printf("loading model %s\n", mod->name);
 
        mod->used = true;
        mod->crc = (unsigned int)-1;
        mod->loaded = false;
 
        VectorClear(mod->normalmins);
        VectorClear(mod->normalmaxs);
        VectorClear(mod->yawmins);
        VectorClear(mod->yawmaxs);
        VectorClear(mod->rotatedmins);
        VectorClear(mod->rotatedmaxs);
 
        mod->modeldatatypestring = "null";
        mod->type = mod_null;
        mod->Draw = R_Model_Null_Draw;
        mod->numframes = 2;
        mod->numskins = 1;
 
        // no fatal errors occurred, so this model is ready to use.
        mod->loaded = true;
 
        return mod;
    }
 
    crc = 0;
    buf = NULL;
 
    // even if the model is loaded it still may need reloading...
 
    // if it is not loaded or checkdisk is true we need to calculate the crc
    if (!mod->loaded || checkdisk)
    {
        if (checkdisk && mod->loaded)
            Con_DPrintf("checking model %s\n", mod->name);
        buf = FS_LoadFile (mod->name, tempmempool, false, &filesize);
        if (buf)
        {
            crc = CRC_Block((unsigned char *)buf, filesize);
            // we need to reload the model if the crc does not match
            if (mod->crc != crc)
                mod->loaded = false;
        }
    }
 
    // if the model is already loaded and checks passed, just return
    if (mod->loaded)
    {
        if (buf)
            Mem_Free(buf);
        return mod;
    }
 
    if (developer_loading.integer)
        Con_Printf("loading model %s\n", mod->name);
    
    SCR_PushLoadingScreen(mod->name, 1);
 
    // LadyHavoc: unload the existing model in this slot (if there is one)
    if (mod->loaded || mod->mempool)
        Mod_UnloadModel(mod);
 
    // load the model
    mod->used = true;
    mod->crc = crc;
    // errors can prevent the corresponding mod->loaded = true;
    mod->loaded = false;
 
    // default lightmap scale
    mod->lightmapscale = 1;
 
    // default model radius and bounding box (mainly for missing models)
    mod->radius = 16;
    VectorSet(mod->normalmins, -mod->radius, -mod->radius, -mod->radius);
    VectorSet(mod->normalmaxs, mod->radius, mod->radius, mod->radius);
    VectorSet(mod->yawmins, -mod->radius, -mod->radius, -mod->radius);
    VectorSet(mod->yawmaxs, mod->radius, mod->radius, mod->radius);
    VectorSet(mod->rotatedmins, -mod->radius, -mod->radius, -mod->radius);
    VectorSet(mod->rotatedmaxs, mod->radius, mod->radius, mod->radius);
 
    if (!q3shaders_mem)
    {
        // load q3 shaders for the first time, or after a level change
        Mod_LoadQ3Shaders();
    }
 
    if (buf)
    {
        int i;
        const char *ext = FS_FileExtension(mod->name);  
        char *bufend = (char *)buf + filesize;
        // all models use memory, so allocate a memory pool
        mod->mempool = Mem_AllocPool(mod->name, 0, NULL);
 
        // We need to have a reference to the base model in case we're parsing submodels
        loadmodel = mod;
 
        // Call the appropriate loader. Try matching magic bytes.
        for (i = 0; loader[i].Load; i++)
        {
            // Headerless formats can just load based on extension. Otherwise match the magic string.
            if((loader[i].extension && !strcasecmp(ext, loader[i].extension) && !loader[i].header) ||
               (loader[i].header && !memcmp(buf, loader[i].header, loader[i].headersize)))
            {
                // Matched. Load it.
                loader[i].Load(mod, buf, bufend);
                Mem_Free(buf);
 
                Mod_FindPotentialDeforms(mod);
 
                buf = FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.framegroups", mod->name), tempmempool, false, &filesize);
                if(buf)
                {
                    Mod_FrameGroupify(mod, (const char *)buf);
                    Mem_Free(buf);
                }
 
                Mod_SetDrawSkyAndWater(mod);
                Mod_BuildVBOs();
                break;
            }
        }
        if(!loader[i].Load)
            Con_Printf(CON_ERROR "Mod_LoadModel: model \"%s\" is of unknown/unsupported type\n", mod->name);
    }
    else if (crash)
        // LadyHavoc: Sys_Error was *ANNOYING*
        Con_Printf (CON_ERROR "Mod_LoadModel: %s not found\n", mod->name);
 
    // no fatal errors occurred, so this model is ready to use.
    mod->loaded = true;
 
    SCR_PopLoadingScreen(false);
 
    return mod;
}

References buf, Con_DPrintf(), CON_ERROR, Con_Printf(), crash(), CRC_Block(), developer_loading, FS_FileExtension(), FS_LoadFile(), i, int(), cvar_t::integer, modloader_t::Load, loader, loadmodel, Mem_AllocPool, Mem_Free, mod(), Mod_BuildVBOs(), Mod_FindPotentialDeforms(), Mod_FrameGroupify(), Mod_LoadQ3Shaders(), mod_null, Mod_SetDrawSkyAndWater(), Mod_UnloadModel(), NULL, q3shaders_mem, R_Model_Null_Draw(), SCR_PopLoadingScreen(), SCR_PushLoadingScreen(), tempmempool, va(), VectorClear, and VectorSet.

Referenced by Mod_ForName(), Mod_Reload(), and mod_start().

Mod_LoadQ3Shaders()

void Mod_LoadQ3Shaders

(

void

)

Definition at line 1466 of file model_shared.c.

{
    int j;
    int fileindex;
    fssearch_t *search;
    char *f;
    const char *text;
    shader_t shader;
    q3shaderinfo_layer_t *layer;
    int numparameters;
    char parameter[TEXTURE_MAXFRAMES + 4][Q3PATHLENGTH];
    char *custsurfaceparmnames[256]; // VorteX: q3map2 has 64 but well, someone will need more
    unsigned long custsurfaceflags[256]; 
    int numcustsurfaceflags;
    qbool dpshaderkill;
 
    Mod_FreeQ3Shaders();
 
    q3shaders_mem = Mem_AllocPool("q3shaders", 0, NULL);
    q3shader_data = (q3shader_data_t*)Mem_Alloc (q3shaders_mem,
        sizeof (q3shader_data_t));
    Mem_ExpandableArray_NewArray (&q3shader_data->hash_entries,
        q3shaders_mem, sizeof (q3shader_hash_entry_t), 256);
    Mem_ExpandableArray_NewArray (&q3shader_data->char_ptrs,
        q3shaders_mem, sizeof (char**), 256);
 
    // parse custinfoparms.txt
    numcustsurfaceflags = 0;
    if ((text = f = (char *)FS_LoadFile("scripts/custinfoparms.txt", tempmempool, false, NULL)) != NULL)
    {
        if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
            Con_DPrintf("scripts/custinfoparms.txt: contentflags section parsing error - expected \"{\", found \"%s\"\n", com_token);
        else
        {
            while (COM_ParseToken_QuakeC(&text, false))
                if (!strcasecmp(com_token, "}"))
                    break;
            // custom surfaceflags section
            if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
                Con_DPrintf("scripts/custinfoparms.txt: surfaceflags section parsing error - expected \"{\", found \"%s\"\n", com_token);
            else
            {
                while(COM_ParseToken_QuakeC(&text, false))
                {
                    if (!strcasecmp(com_token, "}"))
                        break;  
                    // register surfaceflag
                    if (numcustsurfaceflags >= 256)
                    {
                        Con_Printf("scripts/custinfoparms.txt: surfaceflags section parsing error - max 256 surfaceflags exceeded\n");
                        break;
                    }
                    // name
                    j = (int)strlen(com_token)+1;
                    custsurfaceparmnames[numcustsurfaceflags] = (char *)Mem_Alloc(tempmempool, j);
                    dp_strlcpy(custsurfaceparmnames[numcustsurfaceflags], com_token, j+1);
                    // value
                    if (COM_ParseToken_QuakeC(&text, false))
                        custsurfaceflags[numcustsurfaceflags] = strtol(com_token, NULL, 0);
                    else
                        custsurfaceflags[numcustsurfaceflags] = 0;
                    numcustsurfaceflags++;
                }
            }
        }
        Mem_Free(f);
    }
 
    // parse shaders
    search = FS_Search("scripts/*.shader", true, false, NULL);
    if (!search)
        return;
    for (fileindex = 0;fileindex < search->numfilenames;fileindex++)
    {
        text = f = (char *)FS_LoadFile(search->filenames[fileindex], tempmempool, false, NULL);
        if (!f)
            continue;
        while (COM_ParseToken_QuakeC(&text, false))
        {
            memset (&shader, 0, sizeof(shader));
            shader.name[0] = 0;
            shader.surfaceparms = 0;
            shader.surfaceflags = 0;
            shader.textureflags = 0;
            shader.numlayers = 0;
            shader.lighting = false;
            shader.vertexalpha = false;
            shader.textureblendalpha = false;
            shader.skyboxname[0] = 0;
            shader.deforms[0].deform = Q3DEFORM_NONE;
            shader.dpnortlight = false;
            shader.dpshadow = false;
            shader.dpnoshadow = false;
            shader.dpmeshcollisions = false;
            shader.dpshaderkill = false;
            shader.dpreflectcube[0] = 0;
            shader.reflectmin = 0;
            shader.reflectmax = 1;
            shader.refractfactor = 1;
            Vector4Set(shader.refractcolor4f, 1, 1, 1, 1);
            shader.reflectfactor = 1;
            Vector4Set(shader.reflectcolor4f, 1, 1, 1, 1);
            shader.r_water_wateralpha = 1;
            shader.r_water_waterscroll[0] = 0;
            shader.r_water_waterscroll[1] = 0;
            shader.offsetmapping = (mod_q3shader_default_offsetmapping.value) ? OFFSETMAPPING_DEFAULT : OFFSETMAPPING_OFF;
            shader.offsetscale = mod_q3shader_default_offsetmapping_scale.value;
            shader.offsetbias = mod_q3shader_default_offsetmapping_bias.value;
            shader.biaspolygonoffset = mod_q3shader_default_polygonoffset.value;
            shader.biaspolygonfactor = mod_q3shader_default_polygonfactor.value;
            shader.transparentsort = TRANSPARENTSORT_DISTANCE;
            shader.specularscalemod = 1;
            shader.specularpowermod = 1;
            shader.rtlightambient = 0;
            // WHEN ADDING DEFAULTS HERE, REMEMBER TO PUT DEFAULTS IN ALL LOADERS
            // JUST GREP FOR "specularscalemod = 1".
 
            dp_strlcpy(shader.name, com_token, sizeof(shader.name));
            if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
            {
                Con_DPrintf("%s parsing error - expected \"{\", found \"%s\"\n", search->filenames[fileindex], com_token);
                break;
            }
            while (COM_ParseToken_QuakeC(&text, false))
            {
                if (!strcasecmp(com_token, "}"))
                    break;
                if (!strcasecmp(com_token, "{"))
                {
                    static q3shaderinfo_layer_t dummy;
                    if (shader.numlayers < Q3SHADER_MAXLAYERS)
                    {
                        layer = shader.layers + shader.numlayers++;
                    }
                    else
                    {
                        // parse and process it anyway, just don't store it (so a map $lightmap or such stuff still is found)
                        memset(&dummy, 0, sizeof(dummy));
                        layer = &dummy;
                    }
                    layer->rgbgen.rgbgen = Q3RGBGEN_IDENTITY;
                    layer->alphagen.alphagen = Q3ALPHAGEN_IDENTITY;
                    layer->tcgen.tcgen = Q3TCGEN_TEXTURE;
                    layer->blendfunc[0] = GL_ONE;
                    layer->blendfunc[1] = GL_ZERO;
                    while (COM_ParseToken_QuakeC(&text, false))
                    {
                        if (!strcasecmp(com_token, "}"))
                            break;
                        if (!strcasecmp(com_token, "\n"))
                            continue;
                        numparameters = 0;
                        for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
                        {
                            if (j < TEXTURE_MAXFRAMES + 4)
                            {
                                // remap dp_water to dpwater, dp_reflect to dpreflect, etc.
                                if(j == 0 && !strncasecmp(com_token, "dp_", 3))
                                    dpsnprintf(parameter[j], sizeof(parameter[j]), "dp%s", &com_token[3]);
                                else
                                    dp_strlcpy(parameter[j], com_token, sizeof(parameter[j]));
                                numparameters = j + 1;
                            }
                            if (!COM_ParseToken_QuakeC(&text, true))
                                break;
                        }
                        //for (j = numparameters;j < TEXTURE_MAXFRAMES + 4;j++)
                        //  parameter[j][0] = 0;
                        if (developer_insane.integer)
                        {
                            Con_DPrintf("%s %i: ", shader.name, shader.numlayers - 1);
                            for (j = 0;j < numparameters;j++)
                                Con_DPrintf(" %s", parameter[j]);
                            Con_DPrint("\n");
                        }
                        if (numparameters >= 2 && !strcasecmp(parameter[0], "blendfunc"))
                        {
                            if (numparameters == 2)
                            {
                                if (!strcasecmp(parameter[1], "add"))
                                {
                                    layer->blendfunc[0] = GL_ONE;
                                    layer->blendfunc[1] = GL_ONE;
                                }
                                else if (!strcasecmp(parameter[1], "addalpha"))
                                {
                                    layer->blendfunc[0] = GL_SRC_ALPHA;
                                    layer->blendfunc[1] = GL_ONE;
                                }
                                else if (!strcasecmp(parameter[1], "filter"))
                                {
                                    layer->blendfunc[0] = GL_DST_COLOR;
                                    layer->blendfunc[1] = GL_ZERO;
                                }
                                else if (!strcasecmp(parameter[1], "blend"))
                                {
                                    layer->blendfunc[0] = GL_SRC_ALPHA;
                                    layer->blendfunc[1] = GL_ONE_MINUS_SRC_ALPHA;
                                }
                            }
                            else if (numparameters == 3)
                            {
                                int k;
                                for (k = 0;k < 2;k++)
                                {
                                    if (!strcasecmp(parameter[k+1], "GL_ONE"))
                                        layer->blendfunc[k] = GL_ONE;
                                    else if (!strcasecmp(parameter[k+1], "GL_ZERO"))
                                        layer->blendfunc[k] = GL_ZERO;
                                    else if (!strcasecmp(parameter[k+1], "GL_SRC_COLOR"))
                                        layer->blendfunc[k] = GL_SRC_COLOR;
                                    else if (!strcasecmp(parameter[k+1], "GL_SRC_ALPHA"))
                                        layer->blendfunc[k] = GL_SRC_ALPHA;
                                    else if (!strcasecmp(parameter[k+1], "GL_DST_COLOR"))
                                        layer->blendfunc[k] = GL_DST_COLOR;
                                    else if (!strcasecmp(parameter[k+1], "GL_DST_ALPHA"))
                                        layer->blendfunc[k] = GL_DST_ALPHA;
                                    else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_COLOR"))
                                        layer->blendfunc[k] = GL_ONE_MINUS_SRC_COLOR;
                                    else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_ALPHA"))
                                        layer->blendfunc[k] = GL_ONE_MINUS_SRC_ALPHA;
                                    else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_COLOR"))
                                        layer->blendfunc[k] = GL_ONE_MINUS_DST_COLOR;
                                    else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_ALPHA"))
                                        layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
                                    else
                                        layer->blendfunc[k] = GL_ONE; // default in case of parsing error
                                }
                            }
                        }
                        if (numparameters >= 2 && !strcasecmp(parameter[0], "alphafunc"))
                            layer->alphatest = true;
                        if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap")))
                        {
                            if (!strcasecmp(parameter[0], "clampmap"))
                                layer->clampmap = true;
                            layer->numframes = 1;
                            layer->framerate = 1;
                            layer->texturename = (char**)Mem_ExpandableArray_AllocRecord (
                                &q3shader_data->char_ptrs);
                            layer->texturename[0] = Mem_strdup (q3shaders_mem, parameter[1]);
                            if (!strcasecmp(parameter[1], "$lightmap"))
                                shader.lighting = true;
                        }
                        else if (numparameters >= 3 && (!strcasecmp(parameter[0], "animmap") || !strcasecmp(parameter[0], "animclampmap")))
                        {
                            int i;
                            layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES);
                            layer->framerate = atof(parameter[1]);
                            layer->texturename = (char **) Mem_Alloc (q3shaders_mem, sizeof (char*) * layer->numframes);
                            for (i = 0;i < layer->numframes;i++)
                                layer->texturename[i] = Mem_strdup (q3shaders_mem, parameter[i + 2]);
                        }
                        else if (numparameters >= 2 && !strcasecmp(parameter[0], "rgbgen"))
                        {
                            int i;
                            for (i = 0;i < numparameters - 2 && i < Q3RGBGEN_MAXPARMS;i++)
                                layer->rgbgen.parms[i] = atof(parameter[i+2]);
                                 if (!strcasecmp(parameter[1], "identity"))         layer->rgbgen.rgbgen = Q3RGBGEN_IDENTITY;
                            else if (!strcasecmp(parameter[1], "const"))            layer->rgbgen.rgbgen = Q3RGBGEN_CONST;
                            else if (!strcasecmp(parameter[1], "entity"))           layer->rgbgen.rgbgen = Q3RGBGEN_ENTITY;
                            else if (!strcasecmp(parameter[1], "exactvertex"))      layer->rgbgen.rgbgen = Q3RGBGEN_EXACTVERTEX;
                            else if (!strcasecmp(parameter[1], "identitylighting")) layer->rgbgen.rgbgen = Q3RGBGEN_IDENTITYLIGHTING;
                            else if (!strcasecmp(parameter[1], "lightingdiffuse"))  layer->rgbgen.rgbgen = Q3RGBGEN_LIGHTINGDIFFUSE;
                            else if (!strcasecmp(parameter[1], "oneminusentity"))   layer->rgbgen.rgbgen = Q3RGBGEN_ONEMINUSENTITY;
                            else if (!strcasecmp(parameter[1], "oneminusvertex"))   layer->rgbgen.rgbgen = Q3RGBGEN_ONEMINUSVERTEX;
                            else if (!strcasecmp(parameter[1], "vertex"))           layer->rgbgen.rgbgen = Q3RGBGEN_VERTEX;
                            else if (!strcasecmp(parameter[1], "wave"))
                            {
                                layer->rgbgen.rgbgen = Q3RGBGEN_WAVE;
                                layer->rgbgen.wavefunc = Mod_LoadQ3Shaders_EnumerateWaveFunc(parameter[2]);
                                for (i = 0;i < numparameters - 3 && i < Q3WAVEPARMS;i++)
                                    layer->rgbgen.waveparms[i] = atof(parameter[i+3]);
                            }
                            else Con_DPrintf("%s parsing warning: unknown rgbgen %s\n", search->filenames[fileindex], parameter[1]);
                        }
                        else if (numparameters >= 2 && !strcasecmp(parameter[0], "alphagen"))
                        {
                            int i;
                            for (i = 0;i < numparameters - 2 && i < Q3ALPHAGEN_MAXPARMS;i++)
                                layer->alphagen.parms[i] = atof(parameter[i+2]);
                                 if (!strcasecmp(parameter[1], "identity"))         layer->alphagen.alphagen = Q3ALPHAGEN_IDENTITY;
                            else if (!strcasecmp(parameter[1], "const"))            layer->alphagen.alphagen = Q3ALPHAGEN_CONST;
                            else if (!strcasecmp(parameter[1], "entity"))           layer->alphagen.alphagen = Q3ALPHAGEN_ENTITY;
                            else if (!strcasecmp(parameter[1], "lightingspecular")) layer->alphagen.alphagen = Q3ALPHAGEN_LIGHTINGSPECULAR;
                            else if (!strcasecmp(parameter[1], "oneminusentity"))   layer->alphagen.alphagen = Q3ALPHAGEN_ONEMINUSENTITY;
                            else if (!strcasecmp(parameter[1], "oneminusvertex"))   layer->alphagen.alphagen = Q3ALPHAGEN_ONEMINUSVERTEX;
                            else if (!strcasecmp(parameter[1], "portal"))           layer->alphagen.alphagen = Q3ALPHAGEN_PORTAL;
                            else if (!strcasecmp(parameter[1], "vertex"))           layer->alphagen.alphagen = Q3ALPHAGEN_VERTEX;
                            else if (!strcasecmp(parameter[1], "wave"))
                            {
                                layer->alphagen.alphagen = Q3ALPHAGEN_WAVE;
                                layer->alphagen.wavefunc = Mod_LoadQ3Shaders_EnumerateWaveFunc(parameter[2]);
                                for (i = 0;i < numparameters - 3 && i < Q3WAVEPARMS;i++)
                                    layer->alphagen.waveparms[i] = atof(parameter[i+3]);
                            }
                            else Con_DPrintf("%s parsing warning: unknown alphagen %s\n", search->filenames[fileindex], parameter[1]);
                        }
                        else if (numparameters >= 2 && (!strcasecmp(parameter[0], "texgen") || !strcasecmp(parameter[0], "tcgen")))
                        {
                            int i;
                            // observed values: tcgen environment
                            // no other values have been observed in real shaders
                            for (i = 0;i < numparameters - 2 && i < Q3TCGEN_MAXPARMS;i++)
                                layer->tcgen.parms[i] = atof(parameter[i+2]);
                                 if (!strcasecmp(parameter[1], "base"))        layer->tcgen.tcgen = Q3TCGEN_TEXTURE;
                            else if (!strcasecmp(parameter[1], "texture"))     layer->tcgen.tcgen = Q3TCGEN_TEXTURE;
                            else if (!strcasecmp(parameter[1], "environment")) layer->tcgen.tcgen = Q3TCGEN_ENVIRONMENT;
                            else if (!strcasecmp(parameter[1], "lightmap"))    layer->tcgen.tcgen = Q3TCGEN_LIGHTMAP;
                            else if (!strcasecmp(parameter[1], "vector"))      layer->tcgen.tcgen = Q3TCGEN_VECTOR;
                            else Con_DPrintf("%s parsing warning: unknown tcgen mode %s\n", search->filenames[fileindex], parameter[1]);
                        }
                        else if (numparameters >= 2 && !strcasecmp(parameter[0], "tcmod"))
                        {
                            int i, tcmodindex;
                            // observed values:
                            // tcmod rotate #
                            // tcmod scale # #
                            // tcmod scroll # #
                            // tcmod stretch sin # # # #
                            // tcmod stretch triangle # # # #
                            // tcmod transform # # # # # #
                            // tcmod turb # # # #
                            // tcmod turb sin # # # #  (this is bogus)
                            // no other values have been observed in real shaders
                            for (tcmodindex = 0;tcmodindex < Q3MAXTCMODS;tcmodindex++)
                                if (!layer->tcmods[tcmodindex].tcmod)
                                    break;
                            if (tcmodindex < Q3MAXTCMODS)
                            {
                                for (i = 0;i < numparameters - 2 && i < Q3TCMOD_MAXPARMS;i++)
                                    layer->tcmods[tcmodindex].parms[i] = atof(parameter[i+2]);
                                     if (!strcasecmp(parameter[1], "entitytranslate")) layer->tcmods[tcmodindex].tcmod = Q3TCMOD_ENTITYTRANSLATE;
                                else if (!strcasecmp(parameter[1], "rotate"))          layer->tcmods[tcmodindex].tcmod = Q3TCMOD_ROTATE;
                                else if (!strcasecmp(parameter[1], "scale"))           layer->tcmods[tcmodindex].tcmod = Q3TCMOD_SCALE;
                                else if (!strcasecmp(parameter[1], "scroll"))          layer->tcmods[tcmodindex].tcmod = Q3TCMOD_SCROLL;
                                else if (!strcasecmp(parameter[1], "page"))            layer->tcmods[tcmodindex].tcmod = Q3TCMOD_PAGE;
                                else if (!strcasecmp(parameter[1], "stretch"))
                                {
                                    layer->tcmods[tcmodindex].tcmod = Q3TCMOD_STRETCH;
                                    layer->tcmods[tcmodindex].wavefunc = Mod_LoadQ3Shaders_EnumerateWaveFunc(parameter[2]);
                                    for (i = 0;i < numparameters - 3 && i < Q3WAVEPARMS;i++)
                                        layer->tcmods[tcmodindex].waveparms[i] = atof(parameter[i+3]);
                                }
                                else if (!strcasecmp(parameter[1], "transform"))       layer->tcmods[tcmodindex].tcmod = Q3TCMOD_TRANSFORM;
                                else if (!strcasecmp(parameter[1], "turb"))            layer->tcmods[tcmodindex].tcmod = Q3TCMOD_TURBULENT;
                                else Con_DPrintf("%s parsing warning: unknown tcmod mode %s\n", search->filenames[fileindex], parameter[1]);
                            }
                            else
                                Con_DPrintf("%s parsing warning: too many tcmods on one layer\n", search->filenames[fileindex]);
                        }
                        // break out a level if it was a closing brace (not using the character here to not confuse vim)
                        if (!strcasecmp(com_token, "}"))
                            break;
                    }
                    if (layer->rgbgen.rgbgen == Q3RGBGEN_LIGHTINGDIFFUSE || layer->rgbgen.rgbgen == Q3RGBGEN_VERTEX)
                        shader.lighting = true;
                    if (layer->alphagen.alphagen == Q3ALPHAGEN_VERTEX)
                    {
                        if (layer == shader.layers + 0)
                        {
                            // vertex controlled transparency
                            shader.vertexalpha = true;
                        }
                        else
                        {
                            // multilayer terrain shader or similar
                            shader.textureblendalpha = true;
                            if (mod_q3shader_force_terrain_alphaflag.integer)
                                shader.layers[0].dptexflags |= TEXF_ALPHA;
                        }
                    }
 
                    if(mod_q3shader_force_addalpha.integer)
                    {
                        // for a long while, DP treated GL_ONE GL_ONE as GL_SRC_ALPHA GL_ONE
                        // this cvar brings back this behaviour
                        if(layer->blendfunc[0] == GL_ONE && layer->blendfunc[1] == GL_ONE)
                            layer->blendfunc[0] = GL_SRC_ALPHA;
                    }
                    
                    layer->dptexflags = 0;
                    if (layer->alphatest)
                        layer->dptexflags |= TEXF_ALPHA;
                    switch(layer->blendfunc[0])
                    {
                        case GL_SRC_ALPHA:
                        case GL_ONE_MINUS_SRC_ALPHA:
                            layer->dptexflags |= TEXF_ALPHA;
                            break;
                    }
                    switch(layer->blendfunc[1])
                    {
                        case GL_SRC_ALPHA:
                        case GL_ONE_MINUS_SRC_ALPHA:
                            layer->dptexflags |= TEXF_ALPHA;
                            break;
                    }
                    if (!(shader.surfaceparms & Q3SURFACEPARM_NOMIPMAPS))
                        layer->dptexflags |= TEXF_MIPMAP;
                    if (!(shader.textureflags & Q3TEXTUREFLAG_NOPICMIP))
                        layer->dptexflags |= TEXF_PICMIP | TEXF_COMPRESS;
                    if (layer->clampmap)
                        layer->dptexflags |= TEXF_CLAMP;
                    continue;
                }
                numparameters = 0;
                for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
                {
                    if (j < TEXTURE_MAXFRAMES + 4)
                    {
                        // remap dp_water to dpwater, dp_reflect to dpreflect, etc.
                        if(j == 0 && !strncasecmp(com_token, "dp_", 3))
                            dpsnprintf(parameter[j], sizeof(parameter[j]), "dp%s", &com_token[3]);
                        else
                            dp_strlcpy(parameter[j], com_token, sizeof(parameter[j]));
                        numparameters = j + 1;
                    }
                    if (!COM_ParseToken_QuakeC(&text, true))
                        break;
                }
                //for (j = numparameters;j < TEXTURE_MAXFRAMES + 4;j++)
                //  parameter[j][0] = 0;
                if (fileindex == 0 && !strcasecmp(com_token, "}"))
                    break;
                if (developer_insane.integer)
                {
                    Con_DPrintf("%s: ", shader.name);
                    for (j = 0;j < numparameters;j++)
                        Con_DPrintf(" %s", parameter[j]);
                    Con_DPrint("\n");
                }
                if (numparameters < 1)
                    continue;
                if (!strcasecmp(parameter[0], "surfaceparm") && numparameters >= 2)
                {
                    if (!strcasecmp(parameter[1], "alphashadow"))
                        shader.surfaceparms |= Q3SURFACEPARM_ALPHASHADOW;
                    else if (!strcasecmp(parameter[1], "areaportal"))
                        shader.surfaceparms |= Q3SURFACEPARM_AREAPORTAL;
                    else if (!strcasecmp(parameter[1], "botclip"))
                        shader.surfaceparms |= Q3SURFACEPARM_BOTCLIP;
                    else if (!strcasecmp(parameter[1], "clusterportal"))
                        shader.surfaceparms |= Q3SURFACEPARM_CLUSTERPORTAL;
                    else if (!strcasecmp(parameter[1], "detail"))
                        shader.surfaceparms |= Q3SURFACEPARM_DETAIL;
                    else if (!strcasecmp(parameter[1], "donotenter"))
                        shader.surfaceparms |= Q3SURFACEPARM_DONOTENTER;
                    else if (!strcasecmp(parameter[1], "dust"))
                        shader.surfaceparms |= Q3SURFACEPARM_DUST;
                    else if (!strcasecmp(parameter[1], "hint"))
                        shader.surfaceparms |= Q3SURFACEPARM_HINT;
                    else if (!strcasecmp(parameter[1], "fog"))
                        shader.surfaceparms |= Q3SURFACEPARM_FOG;
                    else if (!strcasecmp(parameter[1], "lava"))
                        shader.surfaceparms |= Q3SURFACEPARM_LAVA;
                    else if (!strcasecmp(parameter[1], "lightfilter"))
                        shader.surfaceparms |= Q3SURFACEPARM_LIGHTFILTER;
                    else if (!strcasecmp(parameter[1], "lightgrid"))
                        shader.surfaceparms |= Q3SURFACEPARM_LIGHTGRID;
                    else if (!strcasecmp(parameter[1], "metalsteps"))
                        shader.surfaceparms |= Q3SURFACEPARM_METALSTEPS;
                    else if (!strcasecmp(parameter[1], "nodamage"))
                        shader.surfaceparms |= Q3SURFACEPARM_NODAMAGE;
                    else if (!strcasecmp(parameter[1], "nodlight"))
                        shader.surfaceparms |= Q3SURFACEPARM_NODLIGHT;
                    else if (!strcasecmp(parameter[1], "nodraw"))
                        shader.surfaceparms |= Q3SURFACEPARM_NODRAW;
                    else if (!strcasecmp(parameter[1], "nodrop"))
                        shader.surfaceparms |= Q3SURFACEPARM_NODROP;
                    else if (!strcasecmp(parameter[1], "noimpact"))
                        shader.surfaceparms |= Q3SURFACEPARM_NOIMPACT;
                    else if (!strcasecmp(parameter[1], "nolightmap"))
                        shader.surfaceparms |= Q3SURFACEPARM_NOLIGHTMAP;
                    else if (!strcasecmp(parameter[1], "nomarks"))
                        shader.surfaceparms |= Q3SURFACEPARM_NOMARKS;
                    else if (!strcasecmp(parameter[1], "nomipmaps"))
                        shader.surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
                    else if (!strcasecmp(parameter[1], "nonsolid"))
                        shader.surfaceparms |= Q3SURFACEPARM_NONSOLID;
                    else if (!strcasecmp(parameter[1], "origin"))
                        shader.surfaceparms |= Q3SURFACEPARM_ORIGIN;
                    else if (!strcasecmp(parameter[1], "playerclip"))
                        shader.surfaceparms |= Q3SURFACEPARM_PLAYERCLIP;
                    else if (!strcasecmp(parameter[1], "sky"))
                        shader.surfaceparms |= Q3SURFACEPARM_SKY;
                    else if (!strcasecmp(parameter[1], "slick"))
                        shader.surfaceparms |= Q3SURFACEPARM_SLICK;
                    else if (!strcasecmp(parameter[1], "slime"))
                        shader.surfaceparms |= Q3SURFACEPARM_SLIME;
                    else if (!strcasecmp(parameter[1], "structural"))
                        shader.surfaceparms |= Q3SURFACEPARM_STRUCTURAL;
                    else if (!strcasecmp(parameter[1], "trans"))
                        shader.surfaceparms |= Q3SURFACEPARM_TRANS;
                    else if (!strcasecmp(parameter[1], "water"))
                        shader.surfaceparms |= Q3SURFACEPARM_WATER;
                    else if (!strcasecmp(parameter[1], "pointlight"))
                        shader.surfaceparms |= Q3SURFACEPARM_POINTLIGHT;
                    else if (!strcasecmp(parameter[1], "antiportal"))
                        shader.surfaceparms |= Q3SURFACEPARM_ANTIPORTAL;
                    else if (!strcasecmp(parameter[1], "skip"))
                        ; // shader.surfaceparms |= Q3SURFACEPARM_SKIP; FIXME we don't have enough #defines for this any more, and the engine doesn't need this one anyway
                    else
                    {
                        // try custom surfaceparms
                        for (j = 0; j < numcustsurfaceflags; j++)
                        {
                            if (!strcasecmp(custsurfaceparmnames[j], parameter[1]))
                            {
                                shader.surfaceflags |= custsurfaceflags[j];
                                break;
                            }
                        }
                        // failed all
                        if (j == numcustsurfaceflags)
                            Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]);
                    }
                }
                else if (!strcasecmp(parameter[0], "dpshadow"))
                    shader.dpshadow = true;
                else if (!strcasecmp(parameter[0], "dpnoshadow"))
                    shader.dpnoshadow = true;
                else if (!strcasecmp(parameter[0], "dpnortlight"))
                    shader.dpnortlight = true;
                else if (!strcasecmp(parameter[0], "dpreflectcube"))
                    dp_strlcpy(shader.dpreflectcube, parameter[1], sizeof(shader.dpreflectcube));
                else if (!strcasecmp(parameter[0], "dpmeshcollisions"))
                    shader.dpmeshcollisions = true;
                // this sets dpshaderkill to true if dpshaderkillifcvarzero was used, and to false if dpnoshaderkillifcvarzero was used
                else if (((dpshaderkill = !strcasecmp(parameter[0], "dpshaderkillifcvarzero")) || !strcasecmp(parameter[0], "dpnoshaderkillifcvarzero")) && numparameters >= 2)
                {
                    if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) == 0.0f)
                        shader.dpshaderkill = dpshaderkill;
                }
                // this sets dpshaderkill to true if dpshaderkillifcvar was used, and to false if dpnoshaderkillifcvar was used
                else if (((dpshaderkill = !strcasecmp(parameter[0], "dpshaderkillifcvar")) || !strcasecmp(parameter[0], "dpnoshaderkillifcvar")) && numparameters >= 2)
                {
                    const char *op = NULL;
                    if (numparameters >= 3)
                        op = parameter[2];
                    if(!op)
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) != 0.0f)
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, "=="))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) == atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, "!="))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) != atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, ">"))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) > atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, "<"))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) < atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, ">="))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) >= atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else if (numparameters >= 4 && !strcmp(op, "<="))
                    {
                        if (Cvar_VariableValue(&cvars_all, parameter[1], ~0) <= atof(parameter[3]))
                            shader.dpshaderkill = dpshaderkill;
                    }
                    else
                    {
                        Con_DPrintf("%s parsing warning: unknown dpshaderkillifcvar op \"%s\", or not enough arguments\n", search->filenames[fileindex], op);
                    }
                }
                else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
                {
                    // some q3 skies don't have the sky parm set
                    shader.surfaceparms |= Q3SURFACEPARM_SKY;
                    dp_strlcpy(shader.skyboxname, parameter[1], sizeof(shader.skyboxname));
                }
                else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2)
                {
                    // some q3 skies don't have the sky parm set
                    shader.surfaceparms |= Q3SURFACEPARM_SKY;
                    if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-"))
                        dp_strlcpy(shader.skyboxname, parameter[1], sizeof(shader.skyboxname));
                }
                else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2)
                {
                    if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided"))
                        shader.textureflags |= Q3TEXTUREFLAG_TWOSIDED;
                }
                else if (!strcasecmp(parameter[0], "nomipmaps"))
                    shader.surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
                else if (!strcasecmp(parameter[0], "nopicmip"))
                    shader.textureflags |= Q3TEXTUREFLAG_NOPICMIP;
                else if (!strcasecmp(parameter[0], "polygonoffset"))
                    shader.textureflags |= Q3TEXTUREFLAG_POLYGONOFFSET;
                else if (!strcasecmp(parameter[0], "dppolygonoffset"))
                {
                    shader.textureflags |= Q3TEXTUREFLAG_POLYGONOFFSET;
                    if(numparameters >= 2)
                    {
                        shader.biaspolygonfactor = atof(parameter[1]);
                        if(numparameters >= 3)
                            shader.biaspolygonoffset = atof(parameter[2]);
                        else
                            shader.biaspolygonoffset = 0;
                    }
                }
                else if (!strcasecmp(parameter[0], "dptransparentsort") && numparameters >= 2)
                {
                    shader.textureflags |= Q3TEXTUREFLAG_TRANSPARENTSORT;
                    if (!strcasecmp(parameter[1], "sky"))
                        shader.transparentsort = TRANSPARENTSORT_SKY;
                    else if (!strcasecmp(parameter[1], "distance"))
                        shader.transparentsort = TRANSPARENTSORT_DISTANCE;
                    else if (!strcasecmp(parameter[1], "hud"))
                        shader.transparentsort = TRANSPARENTSORT_HUD;
                    else
                        Con_DPrintf("%s parsing warning: unknown dptransparentsort category \"%s\", or not enough arguments\n", search->filenames[fileindex], parameter[1]);
                }
                else if (!strcasecmp(parameter[0], "dprefract") && numparameters >= 5)
                {
                    shader.textureflags |= Q3TEXTUREFLAG_REFRACTION;
                    shader.refractfactor = atof(parameter[1]);
                    Vector4Set(shader.refractcolor4f, atof(parameter[2]), atof(parameter[3]), atof(parameter[4]), 1);
                }
                else if (!strcasecmp(parameter[0], "dpreflect") && numparameters >= 6)
                {
                    shader.textureflags |= Q3TEXTUREFLAG_REFLECTION;
                    shader.reflectfactor = atof(parameter[1]);
                    Vector4Set(shader.reflectcolor4f, atof(parameter[2]), atof(parameter[3]), atof(parameter[4]), atof(parameter[5]));
                }
                else if (!strcasecmp(parameter[0], "dpcamera"))
                {
                    shader.textureflags |= Q3TEXTUREFLAG_CAMERA;
                }
                else if (!strcasecmp(parameter[0], "dpwater") && numparameters >= 12)
                {
                    shader.textureflags |= Q3TEXTUREFLAG_WATERSHADER;
                    shader.reflectmin = atof(parameter[1]);
                    shader.reflectmax = atof(parameter[2]);
                    shader.refractfactor = atof(parameter[3]);
                    shader.reflectfactor = atof(parameter[4]);
                    Vector4Set(shader.refractcolor4f, atof(parameter[5]), atof(parameter[6]), atof(parameter[7]), 1);
                    Vector4Set(shader.reflectcolor4f, atof(parameter[8]), atof(parameter[9]), atof(parameter[10]), 1);
                    shader.r_water_wateralpha = atof(parameter[11]);
                }
                else if (!strcasecmp(parameter[0], "dpwaterscroll") && numparameters >= 3)
                {
                    shader.r_water_waterscroll[0] = 1/atof(parameter[1]);
                    shader.r_water_waterscroll[1] = 1/atof(parameter[2]);
                }
                else if (!strcasecmp(parameter[0], "dpglossintensitymod") && numparameters >= 2)
                {
                    shader.specularscalemod = atof(parameter[1]);
                }
                else if (!strcasecmp(parameter[0], "dpglossexponentmod") && numparameters >= 2)
                {
                    shader.specularpowermod = atof(parameter[1]);
                }
                else if (!strcasecmp(parameter[0], "dprtlightambient") && numparameters >= 2)
                {
                    shader.rtlightambient = atof(parameter[1]);
                }
                else if (!strcasecmp(parameter[0], "dpoffsetmapping") && numparameters >= 2)
                {
                    if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "off"))
                        shader.offsetmapping = OFFSETMAPPING_OFF;
                    else if (!strcasecmp(parameter[1], "default") || !strcasecmp(parameter[1], "normal"))
                        shader.offsetmapping = OFFSETMAPPING_DEFAULT;
                    else if (!strcasecmp(parameter[1], "linear"))
                        shader.offsetmapping = OFFSETMAPPING_LINEAR;
                    else if (!strcasecmp(parameter[1], "relief"))
                        shader.offsetmapping = OFFSETMAPPING_RELIEF;
                    if (numparameters >= 3)
                        shader.offsetscale = atof(parameter[2]);
                    if (numparameters >= 5)
                    {
                        if(!strcasecmp(parameter[3], "bias"))
                            shader.offsetbias = atof(parameter[4]);
                        else if(!strcasecmp(parameter[3], "match"))
                            shader.offsetbias = 1.0f - atof(parameter[4]);
                        else if(!strcasecmp(parameter[3], "match8"))
                            shader.offsetbias = 1.0f - atof(parameter[4]) / 255.0f;
                        else if(!strcasecmp(parameter[3], "match16"))
                            shader.offsetbias = 1.0f - atof(parameter[4]) / 65535.0f;
                    }
                }
                else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
                {
                    int i, deformindex;
                    for (deformindex = 0;deformindex < Q3MAXDEFORMS;deformindex++)
                        if (!shader.deforms[deformindex].deform)
                            break;
                    if (deformindex < Q3MAXDEFORMS)
                    {
                        for (i = 0;i < numparameters - 2 && i < Q3DEFORM_MAXPARMS;i++)
                            shader.deforms[deformindex].parms[i] = atof(parameter[i+2]);
                             if (!strcasecmp(parameter[1], "projectionshadow")) shader.deforms[deformindex].deform = Q3DEFORM_PROJECTIONSHADOW;
                        else if (!strcasecmp(parameter[1], "autosprite"      )) shader.deforms[deformindex].deform = Q3DEFORM_AUTOSPRITE;
                        else if (!strcasecmp(parameter[1], "autosprite2"     )) shader.deforms[deformindex].deform = Q3DEFORM_AUTOSPRITE2;
                        else if (!strcasecmp(parameter[1], "text0"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT0;
                        else if (!strcasecmp(parameter[1], "text1"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT1;
                        else if (!strcasecmp(parameter[1], "text2"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT2;
                        else if (!strcasecmp(parameter[1], "text3"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT3;
                        else if (!strcasecmp(parameter[1], "text4"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT4;
                        else if (!strcasecmp(parameter[1], "text5"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT5;
                        else if (!strcasecmp(parameter[1], "text6"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT6;
                        else if (!strcasecmp(parameter[1], "text7"           )) shader.deforms[deformindex].deform = Q3DEFORM_TEXT7;
                        else if (!strcasecmp(parameter[1], "bulge"           )) shader.deforms[deformindex].deform = Q3DEFORM_BULGE;
                        else if (!strcasecmp(parameter[1], "normal"          )) shader.deforms[deformindex].deform = Q3DEFORM_NORMAL;
                        else if (!strcasecmp(parameter[1], "wave"            ))
                        {
                            shader.deforms[deformindex].deform = Q3DEFORM_WAVE;
                            shader.deforms[deformindex].wavefunc = Mod_LoadQ3Shaders_EnumerateWaveFunc(parameter[3]);
                            for (i = 0;i < numparameters - 4 && i < Q3WAVEPARMS;i++)
                                shader.deforms[deformindex].waveparms[i] = atof(parameter[i+4]);
                        }
                        else if (!strcasecmp(parameter[1], "move"            ))
                        {
                            shader.deforms[deformindex].deform = Q3DEFORM_MOVE;
                            shader.deforms[deformindex].wavefunc = Mod_LoadQ3Shaders_EnumerateWaveFunc(parameter[5]);
                            for (i = 0;i < numparameters - 6 && i < Q3WAVEPARMS;i++)
                                shader.deforms[deformindex].waveparms[i] = atof(parameter[i+6]);
                        }
                    }
                }
            }
            // hide this shader if a cvar said it should be killed
            if (shader.dpshaderkill)
                shader.numlayers = 0;
            // fix up multiple reflection types
            if(shader.textureflags & Q3TEXTUREFLAG_WATERSHADER)
                shader.textureflags &= ~(Q3TEXTUREFLAG_REFRACTION | Q3TEXTUREFLAG_REFLECTION | Q3TEXTUREFLAG_CAMERA);
 
            Q3Shader_AddToHash (&shader);
        }
        Mem_Free(f);
    }
    FS_FreeSearch(search);
    // free custinfoparm values
    for (j = 0; j < numcustsurfaceflags; j++)
        Mem_Free(custsurfaceparmnames[j]);
}

References shader_t::biaspolygonfactor, shader_t::biaspolygonoffset, q3shader_data_t::char_ptrs, COM_ParseToken_QuakeC(), com_token, Con_DPrint(), Con_DPrintf(), Con_Printf(), Cvar_VariableValue(), cvars_all, q3shaderinfo_deform_t::deform, shader_t::deforms, developer_insane, dp_strlcpy, shader_t::dpmeshcollisions, shader_t::dpnortlight, shader_t::dpnoshadow, shader_t::dpreflectcube, shader_t::dpshaderkill, shader_t::dpshadow, dpsnprintf(), q3shaderinfo_layer_t::dptexflags, f, fssearch_t::filenames, FS_FreeSearch(), FS_LoadFile(), FS_Search(), GL_DST_ALPHA, GL_DST_COLOR, GL_ONE, GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_COLOR, GL_ZERO, q3shader_data_t::hash_entries, i, int(), cvar_t::integer, layer, shader_t::layers, shader_t::lighting, Mem_Alloc, Mem_AllocPool, Mem_ExpandableArray_AllocRecord(), Mem_ExpandableArray_NewArray(), Mem_Free, Mem_strdup, min, Mod_FreeQ3Shaders(), Mod_LoadQ3Shaders_EnumerateWaveFunc(), mod_q3shader_default_offsetmapping, mod_q3shader_default_offsetmapping_bias, mod_q3shader_default_offsetmapping_scale, mod_q3shader_default_polygonfactor, mod_q3shader_default_polygonoffset, mod_q3shader_force_addalpha, mod_q3shader_force_terrain_alphaflag, shader_t::name, NULL, fssearch_t::numfilenames, shader_t::numlayers, shader_t::offsetbias, shader_t::offsetmapping, OFFSETMAPPING_DEFAULT, OFFSETMAPPING_LINEAR, OFFSETMAPPING_OFF, OFFSETMAPPING_RELIEF, shader_t::offsetscale, q3shaderinfo_deform_t::parms, Q3ALPHAGEN_CONST, Q3ALPHAGEN_ENTITY, Q3ALPHAGEN_IDENTITY, Q3ALPHAGEN_LIGHTINGSPECULAR, Q3ALPHAGEN_MAXPARMS, Q3ALPHAGEN_ONEMINUSENTITY, Q3ALPHAGEN_ONEMINUSVERTEX, Q3ALPHAGEN_PORTAL, Q3ALPHAGEN_VERTEX, Q3ALPHAGEN_WAVE, Q3DEFORM_AUTOSPRITE, Q3DEFORM_AUTOSPRITE2, Q3DEFORM_BULGE, Q3DEFORM_MAXPARMS, Q3DEFORM_MOVE, Q3DEFORM_NONE, Q3DEFORM_NORMAL, Q3DEFORM_PROJECTIONSHADOW, Q3DEFORM_TEXT0, Q3DEFORM_TEXT1, Q3DEFORM_TEXT2, Q3DEFORM_TEXT3, Q3DEFORM_TEXT4, Q3DEFORM_TEXT5, Q3DEFORM_TEXT6, Q3DEFORM_TEXT7, Q3DEFORM_WAVE, Q3MAXDEFORMS, Q3MAXTCMODS, Q3PATHLENGTH, Q3RGBGEN_CONST, Q3RGBGEN_ENTITY, Q3RGBGEN_EXACTVERTEX, Q3RGBGEN_IDENTITY, Q3RGBGEN_IDENTITYLIGHTING, Q3RGBGEN_LIGHTINGDIFFUSE, Q3RGBGEN_MAXPARMS, Q3RGBGEN_ONEMINUSENTITY, Q3RGBGEN_ONEMINUSVERTEX, Q3RGBGEN_VERTEX, Q3RGBGEN_WAVE, Q3Shader_AddToHash(), q3shader_data, Q3SHADER_MAXLAYERS, q3shaders_mem, Q3SURFACEPARM_ALPHASHADOW, Q3SURFACEPARM_ANTIPORTAL, Q3SURFACEPARM_AREAPORTAL, Q3SURFACEPARM_BOTCLIP, Q3SURFACEPARM_CLUSTERPORTAL, Q3SURFACEPARM_DETAIL, Q3SURFACEPARM_DONOTENTER, Q3SURFACEPARM_DUST, Q3SURFACEPARM_FOG, Q3SURFACEPARM_HINT, Q3SURFACEPARM_LAVA, Q3SURFACEPARM_LIGHTFILTER, Q3SURFACEPARM_LIGHTGRID, Q3SURFACEPARM_METALSTEPS, Q3SURFACEPARM_NODAMAGE, Q3SURFACEPARM_NODLIGHT, Q3SURFACEPARM_NODRAW, Q3SURFACEPARM_NODROP, Q3SURFACEPARM_NOIMPACT, Q3SURFACEPARM_NOLIGHTMAP, Q3SURFACEPARM_NOMARKS, Q3SURFACEPARM_NOMIPMAPS, Q3SURFACEPARM_NONSOLID, Q3SURFACEPARM_ORIGIN, Q3SURFACEPARM_PLAYERCLIP, Q3SURFACEPARM_POINTLIGHT, Q3SURFACEPARM_SKY, Q3SURFACEPARM_SLICK, Q3SURFACEPARM_SLIME, Q3SURFACEPARM_STRUCTURAL, Q3SURFACEPARM_TRANS, Q3SURFACEPARM_WATER, Q3TCGEN_ENVIRONMENT, Q3TCGEN_LIGHTMAP, Q3TCGEN_MAXPARMS, Q3TCGEN_TEXTURE, Q3TCGEN_VECTOR, Q3TCMOD_ENTITYTRANSLATE, Q3TCMOD_MAXPARMS, Q3TCMOD_PAGE, Q3TCMOD_ROTATE, Q3TCMOD_SCALE, Q3TCMOD_SCROLL, Q3TCMOD_STRETCH, Q3TCMOD_TRANSFORM, Q3TCMOD_TURBULENT, Q3TEXTUREFLAG_CAMERA, Q3TEXTUREFLAG_NOPICMIP, Q3TEXTUREFLAG_POLYGONOFFSET, Q3TEXTUREFLAG_REFLECTION, Q3TEXTUREFLAG_REFRACTION, Q3TEXTUREFLAG_TRANSPARENTSORT, Q3TEXTUREFLAG_TWOSIDED, Q3TEXTUREFLAG_WATERSHADER, Q3WAVEPARMS, shader_t::r_water_wateralpha, shader_t::r_water_waterscroll, shader_t::reflectcolor4f, shader_t::reflectfactor, shader_t::reflectmax, shader_t::reflectmin, shader_t::refractcolor4f, shader_t::refractfactor, shader_t::rtlightambient, shader_t::skyboxname, shader_t::specularpowermod, shader_t::specularscalemod, strlen(), shader_t::surfaceflags, shader_t::surfaceparms, tempmempool, TEXF_ALPHA, TEXF_CLAMP, TEXF_COMPRESS, TEXF_MIPMAP, TEXF_PICMIP, TEXTURE_MAXFRAMES, shader_t::textureblendalpha, shader_t::textureflags, shader_t::transparentsort, TRANSPARENTSORT_DISTANCE, TRANSPARENTSORT_HUD, TRANSPARENTSORT_SKY, cvar_t::value, Vector4Set, shader_t::vertexalpha, q3shaderinfo_deform_t::wavefunc, and q3shaderinfo_deform_t::waveparms.

Referenced by Mod_LoadModel(), and Mod_LookupQ3Shader().

Mod_LoadSkinFiles()

skinfile_t * Mod_LoadSkinFiles

(

void

)

Definition at line 2705 of file model_shared.c.

{
    int i, words, line, wordsoverflow;
    char *text;
    const char *data;
    skinfile_t *skinfile = NULL, *first = NULL;
    skinfileitem_t *skinfileitem;
    char word[10][MAX_QPATH];
    char vabuf[1024];
 
/*
sample file:
U_bodyBox,models/players/Legoman/BikerA2.tga
U_RArm,models/players/Legoman/BikerA1.tga
U_LArm,models/players/Legoman/BikerA1.tga
U_armor,common/nodraw
U_sword,common/nodraw
U_shield,common/nodraw
U_homb,common/nodraw
U_backpack,common/nodraw
U_colcha,common/nodraw
tag_head,
tag_weapon,
tag_torso,
*/
    memset(word, 0, sizeof(word));
    for (i = 0;i < 256 && (data = text = (char *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s_%i.skin", loadmodel->name, i), tempmempool, true, NULL));i++)
    {
        // If it's the first file we parse
        if (skinfile == NULL)
        {
            skinfile = (skinfile_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfile_t));
            first = skinfile;
        }
        else
        {
            skinfile->next = (skinfile_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfile_t));
            skinfile = skinfile->next;
        }
        skinfile->next = NULL;
 
        for(line = 0;;line++)
        {
            // parse line
            if (!COM_ParseToken_QuakeC(&data, true))
                break;
            if (!strcmp(com_token, "\n"))
                continue;
            words = 0;
            wordsoverflow = false;
            do
            {
                if (words < 10)
                    dp_strlcpy(word[words++], com_token, sizeof (word[0]));
                else
                    wordsoverflow = true;
            }
            while (COM_ParseToken_QuakeC(&data, true) && strcmp(com_token, "\n"));
            if (wordsoverflow)
            {
                Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: line with too many statements, skipping\n", loadmodel->name, i, line);
                continue;
            }
            // words is always >= 1
            if (!strcmp(word[0], "replace"))
            {
                if (words == 3)
                {
                    if (developer_loading.integer)
                        Con_Printf("Mod_LoadSkinFiles: parsed mesh \"%s\" shader replacement \"%s\"\n", word[1], word[2]);
                    skinfileitem = (skinfileitem_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfileitem_t));
                    skinfileitem->next = skinfile->items;
                    skinfile->items = skinfileitem;
                    dp_strlcpy (skinfileitem->name, word[1], sizeof (skinfileitem->name));
                    dp_strlcpy (skinfileitem->replacement, word[2], sizeof (skinfileitem->replacement));
                }
                else
                    Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: wrong number of parameters to command \"%s\", see documentation in DP_GFX_SKINFILES extension in dpextensions.qc\n", loadmodel->name, i, line, word[0]);
            }
            else if (words >= 2 && !strncmp(word[0], "tag_", 4))
            {
                // tag name, like "tag_weapon,"
                // not used for anything (not even in Quake3)
            }
            else if (words >= 2 && !strcmp(word[1], ","))
            {
                // mesh shader name, like "U_RArm,models/players/Legoman/BikerA1.tga"
                if (developer_loading.integer)
                    Con_Printf("Mod_LoadSkinFiles: parsed mesh \"%s\" shader replacement \"%s\"\n", word[0], word[2]);
                skinfileitem = (skinfileitem_t *)Mem_Alloc(loadmodel->mempool, sizeof(skinfileitem_t));
                skinfileitem->next = skinfile->items;
                skinfile->items = skinfileitem;
                dp_strlcpy (skinfileitem->name, word[0], sizeof (skinfileitem->name));
                dp_strlcpy (skinfileitem->replacement, word[2], sizeof (skinfileitem->replacement));
            }
            else
                Con_Printf("Mod_LoadSkinFiles: parsing error in file \"%s_%i.skin\" on line #%i: does not look like tag or mesh specification, or replace command, see documentation in DP_GFX_SKINFILES extension in dpextensions.qc\n", loadmodel->name, i, line);
        }
        Mem_Free(text);
    }
    if (i)
        loadmodel->numskins = i;
    return first;
}

References COM_ParseToken_QuakeC(), com_token, Con_Printf(), data, developer_loading, dp_strlcpy, first, FS_LoadFile(), i, cvar_t::integer, skinfile_t::items, loadmodel, MAX_QPATH, Mem_Alloc, Mem_Free, model_t::mempool, model_t::name, skinfileitem_t::name, skinfile_t::next, skinfileitem_t::next, NULL, model_t::numskins, skinfileitem_t::replacement, tempmempool, and va().

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_LoadTextureFromQ3Shader()

qbool Mod_LoadTextureFromQ3Shader	(	struct mempool_s *	mempool,
		const char *	modelname,
		texture_t *	texture,
		const char *	name,
		qbool	warnmissing,
		qbool	fallback,
		int	defaulttexflags,
		int	defaultmaterialflags )

Mod_LookupQ3Shader()

shader_t * Mod_LookupQ3Shader

(

const char *

name

)

Definition at line 2219 of file model_shared.c.

{
    unsigned short hash;
    q3shader_hash_entry_t* entry;
    if (!q3shaders_mem)
        Mod_LoadQ3Shaders();
    hash = CRC_Block_CaseInsensitive ((const unsigned char *)name, strlen (name));
    entry = q3shader_data->hash + (hash % Q3SHADER_HASH_SIZE);
    while (entry != NULL)
    {
        if (strcasecmp (entry->shader.name, name) == 0)
            return &entry->shader;
        entry = entry->chain;
    }
    return NULL;
}

References q3shader_hash_entry_t::chain, CRC_Block_CaseInsensitive(), q3shader_data_t::hash, Mod_LoadQ3Shaders(), name, shader_t::name, NULL, q3shader_data, Q3SHADER_HASH_SIZE, q3shaders_mem, q3shader_hash_entry_t::shader, and strlen().

Referenced by Mod_LoadTextureFromQ3Shader().

Mod_MakeCollisionBIH()

bih_t * Mod_MakeCollisionBIH	(	model_t *	model,
		qbool	userendersurfaces,
		bih_t *	out )

Definition at line 7412 of file model_brush.c.

{
    int j;
    int bihnumleafs;
    int bihmaxnodes;
    int brushindex;
    int triangleindex;
    int bihleafindex;
    int nummodelbrushes = model->nummodelbrushes;
    const int *e;
    const int *collisionelement3i;
    const float *collisionvertex3f;
    const int *renderelement3i;
    const float *rendervertex3f;
    bih_leaf_t *bihleafs;
    bih_node_t *bihnodes;
    int *temp_leafsort;
    int *temp_leafsortscratch;
    const msurface_t *surface;
    const q3mbrush_t *brush;
 
    // find out how many BIH leaf nodes we need
    bihnumleafs = 0;
    if (userendersurfaces)
    {
        for (j = model->submodelsurfaces_start;j < model->submodelsurfaces_end;j++)
            bihnumleafs += model->data_surfaces[j].num_triangles;
    }
    else
    {
        for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++)
            if (brush->colbrushf)
                bihnumleafs++;
        for (j = model->submodelsurfaces_start;j < model->submodelsurfaces_end;j++)
        {
            if (model->data_surfaces[j].texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS)
                bihnumleafs += model->data_surfaces[j].num_triangles + model->data_surfaces[j].num_collisiontriangles;
            else
                bihnumleafs += model->data_surfaces[j].num_collisiontriangles;
        }
    }
 
    if (!bihnumleafs)
        return NULL;
 
    // allocate the memory for the BIH leaf nodes
    bihleafs = (bih_leaf_t *)Mem_Alloc(loadmodel->mempool, sizeof(bih_leaf_t) * bihnumleafs);
 
    // now populate the BIH leaf nodes
    bihleafindex = 0;
 
    // add render surfaces
    renderelement3i = model->surfmesh.data_element3i;
    rendervertex3f = model->surfmesh.data_vertex3f;
    for (j = model->submodelsurfaces_start; j < model->submodelsurfaces_end; j++)
    {
        surface = model->data_surfaces + j;
        for (triangleindex = 0, e = renderelement3i + 3*surface->num_firsttriangle;triangleindex < surface->num_triangles;triangleindex++, e += 3)
        {
            if (!userendersurfaces && !(surface->texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS))
                continue;
            bihleafs[bihleafindex].type = BIH_RENDERTRIANGLE;
            bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures;
            bihleafs[bihleafindex].surfaceindex = surface - model->data_surfaces;
            bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firsttriangle;
            bihleafs[bihleafindex].mins[0] = min(rendervertex3f[3*e[0]+0], min(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) - 1;
            bihleafs[bihleafindex].mins[1] = min(rendervertex3f[3*e[0]+1], min(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) - 1;
            bihleafs[bihleafindex].mins[2] = min(rendervertex3f[3*e[0]+2], min(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) - 1;
            bihleafs[bihleafindex].maxs[0] = max(rendervertex3f[3*e[0]+0], max(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) + 1;
            bihleafs[bihleafindex].maxs[1] = max(rendervertex3f[3*e[0]+1], max(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) + 1;
            bihleafs[bihleafindex].maxs[2] = max(rendervertex3f[3*e[0]+2], max(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) + 1;
            bihleafindex++;
        }
    }
 
    if (!userendersurfaces)
    {
        // add collision brushes
        for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++)
        {
            if (!brush->colbrushf)
                continue;
            bihleafs[bihleafindex].type = BIH_BRUSH;
            bihleafs[bihleafindex].textureindex = brush->texture - model->data_textures;
            bihleafs[bihleafindex].surfaceindex = -1;
            bihleafs[bihleafindex].itemindex = brushindex+model->firstmodelbrush;
            VectorCopy(brush->colbrushf->mins, bihleafs[bihleafindex].mins);
            VectorCopy(brush->colbrushf->maxs, bihleafs[bihleafindex].maxs);
            bihleafindex++;
        }
 
        // add collision surfaces
        collisionelement3i = model->brush.data_collisionelement3i;
        collisionvertex3f = model->brush.data_collisionvertex3f;
        for (j = model->submodelsurfaces_start; j < model->submodelsurfaces_end; j++)
        {
            surface = model->data_surfaces + j;
            for (triangleindex = 0, e = collisionelement3i + 3*surface->num_firstcollisiontriangle;triangleindex < surface->num_collisiontriangles;triangleindex++, e += 3)
            {
                bihleafs[bihleafindex].type = BIH_COLLISIONTRIANGLE;
                bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures;
                bihleafs[bihleafindex].surfaceindex = surface - model->data_surfaces;
                bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firstcollisiontriangle;
                bihleafs[bihleafindex].mins[0] = min(collisionvertex3f[3*e[0]+0], min(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) - 1;
                bihleafs[bihleafindex].mins[1] = min(collisionvertex3f[3*e[0]+1], min(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) - 1;
                bihleafs[bihleafindex].mins[2] = min(collisionvertex3f[3*e[0]+2], min(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) - 1;
                bihleafs[bihleafindex].maxs[0] = max(collisionvertex3f[3*e[0]+0], max(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) + 1;
                bihleafs[bihleafindex].maxs[1] = max(collisionvertex3f[3*e[0]+1], max(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) + 1;
                bihleafs[bihleafindex].maxs[2] = max(collisionvertex3f[3*e[0]+2], max(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) + 1;
                bihleafindex++;
            }
        }
    }
 
    // allocate buffers for the produced and temporary data
    bihmaxnodes = bihnumleafs + 1;
    bihnodes = (bih_node_t *)Mem_Alloc(loadmodel->mempool, sizeof(bih_node_t) * bihmaxnodes);
    temp_leafsort = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int) * bihnumleafs * 2);
    temp_leafsortscratch = temp_leafsort + bihnumleafs;
 
    // now build it
    BIH_Build(out, bihnumleafs, bihleafs, bihmaxnodes, bihnodes, temp_leafsort, temp_leafsortscratch);
 
    // we're done with the temporary data
    Mem_Free(temp_leafsort);
 
    // resize the BIH nodes array if it over-allocated
    if (out->maxnodes > out->numnodes)
    {
        out->maxnodes = out->numnodes;
        out->nodes = (bih_node_t *)Mem_Realloc(loadmodel->mempool, out->nodes, out->numnodes * sizeof(bih_node_t));
    }
 
    return out;
}

References texture_t::basematerialflags, BIH_BRUSH, BIH_Build(), BIH_COLLISIONTRIANGLE, BIH_RENDERTRIANGLE, q3mbrush_t::colbrushf, bih_leaf_t::itemindex, loadmodel, MATERIALFLAG_MESHCOLLISIONS, max, bih_t::maxnodes, bih_leaf_t::maxs, Mem_Alloc, Mem_Free, Mem_Realloc, model_t::mempool, min, bih_leaf_t::mins, model, bih_t::nodes, NULL, msurface_t::num_firstcollisiontriangle, msurface_t::num_firsttriangle, bih_t::numnodes, bih_leaf_t::surfaceindex, msurface_t::texture, q3mbrush_t::texture, bih_leaf_t::textureindex, bih_leaf_t::type, and VectorCopy.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_MakeSortedSurfaces()

void Mod_MakeSortedSurfaces

(

model_t *

mod

)

Definition at line 2936 of file model_shared.c.

{
    // make an optimal set of texture-sorted batches to draw...
    int j, k;
    Mod_MakeSortedSurfaces_qsortsurface_t *info;
 
    if(cls.state == ca_dedicated)
        return;
 
    info = (Mod_MakeSortedSurfaces_qsortsurface_t*)Mem_Alloc(loadmodel->mempool, mod->num_surfaces * sizeof(*info));
    if (!mod->modelsurfaces_sorted)
        mod->modelsurfaces_sorted = (int *) Mem_Alloc(loadmodel->mempool, mod->num_surfaces * sizeof(*mod->modelsurfaces_sorted));
    // the goal is to sort by submodel (can't change which submodel a surface belongs to), and then by effects and textures
    for (j = 0; j < mod->num_surfaces; j++)
    {
        info[j].surfaceindex = j;
        info[j].effect = mod->data_surfaces[j].effect;
        info[j].texture = mod->data_surfaces[j].texture;
        info[j].lightmaptexture = mod->data_surfaces[j].lightmaptexture;
    }
    for (k = 0; k < mod->brush.numsubmodels; k++)
        if (mod->brush.submodels[k]->submodelsurfaces_end > mod->brush.submodels[k]->submodelsurfaces_start + 1)
            qsort(info + mod->brush.submodels[k]->submodelsurfaces_start, (size_t)mod->brush.submodels[k]->submodelsurfaces_end - mod->brush.submodels[k]->submodelsurfaces_start, sizeof(*info), Mod_MakeSortedSurfaces_qsortfunc);
    for (j = 0; j < mod->num_surfaces; j++)
        mod->modelsurfaces_sorted[j] = info[j].surfaceindex;
    Mem_Free(info);
}

References ca_dedicated, cls, Mod_MakeSortedSurfaces_qsortsurface_t::effect, Mod_MakeSortedSurfaces_qsortsurface_t::lightmaptexture, loadmodel, Mem_Alloc, Mem_Free, model_t::mempool, mod(), Mod_MakeSortedSurfaces_qsortfunc(), client_static_t::state, Mod_MakeSortedSurfaces_qsortsurface_t::surfaceindex, and Mod_MakeSortedSurfaces_qsortsurface_t::texture.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), Mod_Q3BSP_Load(), and Mod_ZYMOTICMODEL_Load().

Mod_MAP_Load()

void Mod_MAP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 8399 of file model_brush.c.

{
    Host_Error("Mod_MAP_Load: not yet implemented");
}

References Host_Error().

Mod_Mesh_AddSurface()

msurface_t * Mod_Mesh_AddSurface	(	model_t *	mod,
		texture_t *	tex,
		qbool	batchwithprevioussurface )

Definition at line 4528 of file model_shared.c.

{
    msurface_t *surf;
    // batch if possible; primarily useful for UI rendering where bounding boxes don't matter
    if (batchwithprevioussurface && mod->num_surfaces > 0 && mod->data_surfaces[mod->num_surfaces - 1].texture == tex)
        return mod->data_surfaces + mod->num_surfaces - 1;
    // create new surface
    if (mod->max_surfaces == mod->num_surfaces)
    {
        mod->max_surfaces = 2 * max(mod->num_surfaces, 64);
        mod->data_surfaces = (msurface_t *)Mem_Realloc(mod->mempool, mod->data_surfaces, mod->max_surfaces * sizeof(*mod->data_surfaces));
        mod->modelsurfaces_sorted = (int *)Mem_Realloc(mod->mempool, mod->modelsurfaces_sorted, mod->max_surfaces * sizeof(*mod->modelsurfaces_sorted));
    }
    surf = mod->data_surfaces + mod->num_surfaces;
    mod->num_surfaces++;
    memset(surf, 0, sizeof(*surf));
    surf->texture = tex;
    surf->num_firsttriangle = mod->surfmesh.num_triangles;
    surf->num_firstvertex = mod->surfmesh.num_vertices;
    if (tex->basematerialflags & (MATERIALFLAG_SKY))
        mod->DrawSky = R_Mod_DrawSky;
    if (tex->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA))
        mod->DrawAddWaterPlanes = R_Mod_DrawAddWaterPlanes;
    return surf;
}

References texture_t::basematerialflags, MATERIALFLAG_CAMERA, MATERIALFLAG_REFLECTION, MATERIALFLAG_REFRACTION, MATERIALFLAG_SKY, MATERIALFLAG_WATERSHADER, max, Mem_Realloc, mod(), msurface_t::num_firsttriangle, msurface_t::num_firstvertex, R_Mod_DrawAddWaterPlanes(), R_Mod_DrawSky(), and msurface_t::texture.

Referenced by CL_Beam_AddPolygons(), DrawQ_Line(), DrawQ_Pic(), DrawQ_RotPic(), DrawQ_String_Scale(), DrawQ_SuperPic(), R_DebugLine(), and VM_CL_R_PolygonEnd().

Mod_Mesh_AddTriangle()

void Mod_Mesh_AddTriangle	(	model_t *	mod,
		msurface_t *	surf,
		int	e0,
		int	e1,
		int	e2 )

Definition at line 4633 of file model_shared.c.

{
    surfmesh_t *mesh = &mod->surfmesh;
    if (mesh->max_triangles == mesh->num_triangles)
    {
        mesh->max_triangles = 2 * max(mesh->num_triangles, 128);
        mesh->data_element3s = (unsigned short *)Mem_Realloc(mod->mempool, mesh->data_element3s, mesh->max_triangles * sizeof(unsigned short[3]));
        mesh->data_element3i = (int *)Mem_Realloc(mod->mempool, mesh->data_element3i, mesh->max_triangles * sizeof(int[3]));
    }
    mesh->data_element3s[mesh->num_triangles * 3 + 0] = e0;
    mesh->data_element3s[mesh->num_triangles * 3 + 1] = e1;
    mesh->data_element3s[mesh->num_triangles * 3 + 2] = e2;
    mesh->data_element3i[mesh->num_triangles * 3 + 0] = e0;
    mesh->data_element3i[mesh->num_triangles * 3 + 1] = e1;
    mesh->data_element3i[mesh->num_triangles * 3 + 2] = e2;
    mesh->num_triangles++;
    surf->num_triangles++;
}

References surfmesh_t::data_element3i, surfmesh_t::data_element3s, max, surfmesh_t::max_triangles, Mem_Realloc, mod(), msurface_t::num_triangles, and surfmesh_t::num_triangles.

Referenced by CL_Beam_AddQuad(), DrawQ_Line(), DrawQ_Pic(), DrawQ_RotPic(), DrawQ_String_Scale(), DrawQ_SuperPic(), R_DebugLine(), and VM_CL_R_PolygonEnd().

Mod_Mesh_Create()

void Mod_Mesh_Create	(	model_t *	mod,
		const char *	name )

Definition at line 4443 of file model_shared.c.

{
    memset(mod, 0, sizeof(*mod));
    dp_strlcpy(mod->name, name, sizeof(mod->name));
    mod->mempool = Mem_AllocPool(name, 0, NULL);
    mod->texturepool = R_AllocTexturePool();
    mod->Draw = R_Mod_Draw;
    mod->DrawDepth = R_Mod_DrawDepth;
    mod->DrawDebug = R_Mod_DrawDebug;
    mod->DrawPrepass = R_Mod_DrawPrepass;
    mod->GetLightInfo = R_Mod_GetLightInfo;
    mod->DrawShadowMap = R_Mod_DrawShadowMap;
    mod->DrawLight = R_Mod_DrawLight;
}

References dp_strlcpy, Mem_AllocPool, mod(), name, NULL, R_AllocTexturePool(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), and R_Mod_GetLightInfo().

Referenced by CL_MeshEntities_Init(), CL_MeshEntities_Restart(), and CL_MeshEntities_Start().

Mod_Mesh_Destroy()

void Mod_Mesh_Destroy

(

model_t *

mod

)

Definition at line 4458 of file model_shared.c.

{
    Mod_UnloadModel(mod);
}

References mod(), and Mod_UnloadModel().

Referenced by CL_MeshEntities_Restart(), and CL_MeshEntities_Shutdown().

Mod_Mesh_Finalize()

void Mod_Mesh_Finalize

(

model_t *

mod

)

Definition at line 4775 of file model_shared.c.

{
    if (gl_paranoid.integer)
        Mod_Mesh_Validate(mod);
    Mod_Mesh_ComputeBounds(mod);
    Mod_Mesh_MakeSortedSurfaces(mod);
    if(!r_refdef.draw2dstage)
        Mod_BuildTextureVectorsFromNormals(0, mod->surfmesh.num_vertices, mod->surfmesh.num_triangles, mod->surfmesh.data_vertex3f, mod->surfmesh.data_texcoordtexture2f, mod->surfmesh.data_normal3f, mod->surfmesh.data_element3i, mod->surfmesh.data_svector3f, mod->surfmesh.data_tvector3f, true);
    Mod_Mesh_UploadDynamicBuffers(mod);
}

References r_refdef_t::draw2dstage, gl_paranoid, cvar_t::integer, mod(), Mod_BuildTextureVectorsFromNormals(), Mod_Mesh_ComputeBounds(), Mod_Mesh_MakeSortedSurfaces(), Mod_Mesh_UploadDynamicBuffers(), Mod_Mesh_Validate(), and r_refdef.

Referenced by CL_MeshEntities_Scene_FinalizeRenderEntity(), and DrawQ_FlushUI().

Mod_Mesh_GetTexture()

texture_t * Mod_Mesh_GetTexture	(	model_t *	mod,
		const char *	name,
		int	defaultdrawflags,
		int	defaulttexflags,
		int	defaultmaterialflags )

Definition at line 4476 of file model_shared.c.

{
    int i;
    texture_t *t;
    int drawflag = defaultdrawflags & DRAWFLAG_MASK;
    for (i = 0, t = mod->data_textures; i < mod->num_textures; i++, t++)
        if (!strcmp(t->name, name) && t->mesh_drawflag == drawflag && t->mesh_defaulttexflags == defaulttexflags && t->mesh_defaultmaterialflags == defaultmaterialflags)
            return t;
    if (mod->max_textures <= mod->num_textures)
    {
        texture_t *oldtextures = mod->data_textures;
        mod->max_textures = max(mod->max_textures * 2, 1024);
        mod->data_textures = (texture_t *)Mem_Realloc(mod->mempool, mod->data_textures, mod->max_textures * sizeof(*mod->data_textures));
        // update the pointers
        for (i = 0; i < mod->num_surfaces; i++)
            mod->data_surfaces[i].texture = mod->data_textures + (mod->data_surfaces[i].texture - oldtextures);
    }
    t = &mod->data_textures[mod->num_textures++];
    Mod_LoadTextureFromQ3Shader(mod->mempool, mod->name, t, name, true, true, defaulttexflags, defaultmaterialflags);
    t->mesh_drawflag = drawflag;
    t->mesh_defaulttexflags = defaulttexflags;
    t->mesh_defaultmaterialflags = defaultmaterialflags;
    switch (defaultdrawflags & DRAWFLAG_MASK)
    {
    case DRAWFLAG_ADDITIVE:
        t->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED;
        t->currentmaterialflags = t->basematerialflags;
        break;
    case DRAWFLAG_MODULATE:
        t->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_BLENDED;
        t->currentmaterialflags = t->basematerialflags;
        t->customblendfunc[0] = GL_DST_COLOR;
        t->customblendfunc[1] = GL_ZERO;
        break;
    case DRAWFLAG_2XMODULATE:
        t->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_BLENDED;
        t->currentmaterialflags = t->basematerialflags;
        t->customblendfunc[0] = GL_DST_COLOR;
        t->customblendfunc[1] = GL_SRC_COLOR;
        break;
    case DRAWFLAG_SCREEN:
        t->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_BLENDED;
        t->currentmaterialflags = t->basematerialflags;
        t->customblendfunc[0] = GL_ONE_MINUS_DST_COLOR;
        t->customblendfunc[1] = GL_ONE;
        break;
    default:
        break;
    }
    return t;
}

References texture_t::basematerialflags, texture_t::currentmaterialflags, texture_t::customblendfunc, DRAWFLAG_2XMODULATE, DRAWFLAG_ADDITIVE, DRAWFLAG_MASK, DRAWFLAG_MODULATE, DRAWFLAG_SCREEN, GL_DST_COLOR, GL_ONE, GL_ONE_MINUS_DST_COLOR, GL_SRC_COLOR, GL_ZERO, i, MATERIALFLAG_ADD, MATERIALFLAG_BLENDED, MATERIALFLAG_CUSTOMBLEND, max, Mem_Realloc, texture_t::mesh_defaultmaterialflags, texture_t::mesh_defaulttexflags, texture_t::mesh_drawflag, mod(), Mod_LoadTextureFromQ3Shader(), name, and texture_t::name.

Referenced by DrawQ_Line(), DrawQ_Pic(), DrawQ_RotPic(), DrawQ_String_Scale(), DrawQ_SuperPic(), R_DebugLine(), and VM_CL_R_PolygonEnd().

Mod_Mesh_IndexForVertex()

int Mod_Mesh_IndexForVertex	(	model_t *	mod,
		msurface_t *	surf,
		float	x,
		float	y,
		float	z,
		float	nx,
		float	ny,
		float	nz,
		float	s,
		float	t,
		float	u,
		float	v,
		float	r,
		float	g,
		float	b,
		float	a )

Definition at line 4554 of file model_shared.c.

{
    int hashindex, h, vnum, mask;
    surfmesh_t *mesh = &mod->surfmesh;
    if (mesh->max_vertices == mesh->num_vertices)
    {
        mesh->max_vertices = max(mesh->num_vertices * 2, 256);
        mesh->data_vertex3f = (float *)Mem_Realloc(mod->mempool, mesh->data_vertex3f, mesh->max_vertices * sizeof(float[3]));
        mesh->data_svector3f = (float *)Mem_Realloc(mod->mempool, mesh->data_svector3f, mesh->max_vertices * sizeof(float[3]));
        mesh->data_tvector3f = (float *)Mem_Realloc(mod->mempool, mesh->data_tvector3f, mesh->max_vertices * sizeof(float[3]));
        mesh->data_normal3f = (float *)Mem_Realloc(mod->mempool, mesh->data_normal3f, mesh->max_vertices * sizeof(float[3]));
        mesh->data_texcoordtexture2f = (float *)Mem_Realloc(mod->mempool, mesh->data_texcoordtexture2f, mesh->max_vertices * sizeof(float[2]));
        mesh->data_texcoordlightmap2f = (float *)Mem_Realloc(mod->mempool, mesh->data_texcoordlightmap2f, mesh->max_vertices * sizeof(float[2]));
        mesh->data_lightmapcolor4f = (float *)Mem_Realloc(mod->mempool, mesh->data_lightmapcolor4f, mesh->max_vertices * sizeof(float[4]));
        // rebuild the hash table
        mesh->num_vertexhashsize = 4 * mesh->max_vertices;
        mesh->num_vertexhashsize &= ~(mesh->num_vertexhashsize - 1); // round down to pow2
        mesh->data_vertexhash = (int *)Mem_Realloc(mod->mempool, mesh->data_vertexhash, mesh->num_vertexhashsize * sizeof(*mesh->data_vertexhash));
        memset(mesh->data_vertexhash, -1, mesh->num_vertexhashsize * sizeof(*mesh->data_vertexhash));
        mask = mod->surfmesh.num_vertexhashsize - 1;
        // no need to hash the vertices for the entire model, the latest surface will suffice.
        for (vnum = surf ? surf->num_firstvertex : 0; vnum < mesh->num_vertices; vnum++)
        {
            // this uses prime numbers intentionally for computing the hash
            hashindex = (unsigned int)(mesh->data_vertex3f[vnum * 3 + 0] * 2003 + mesh->data_vertex3f[vnum * 3 + 1] * 4001 + mesh->data_vertex3f[vnum * 3 + 2] * 7919 + mesh->data_normal3f[vnum * 3 + 0] * 4097 + mesh->data_normal3f[vnum * 3 + 1] * 257 + mesh->data_normal3f[vnum * 3 + 2] * 17) & mask;
            for (h = hashindex; mesh->data_vertexhash[h] >= 0; h = (h + 1) & mask)
                ; // just iterate until we find the terminator
            mesh->data_vertexhash[h] = vnum;
        }
    }
    mask = mod->surfmesh.num_vertexhashsize - 1;
    // this uses prime numbers intentionally for computing the hash
    hashindex = (unsigned int)(x * 2003 + y * 4001 + z * 7919 + nx * 4097 + ny * 257 + nz * 17) & mask;
    // when possible find an identical vertex within the same surface and return it
    for(h = hashindex;(vnum = mesh->data_vertexhash[h]) >= 0;h = (h + 1) & mask)
    {
        if (vnum >= surf->num_firstvertex
         && mesh->data_vertex3f[vnum * 3 + 0] == x && mesh->data_vertex3f[vnum * 3 + 1] == y && mesh->data_vertex3f[vnum * 3 + 2] == z
         && mesh->data_normal3f[vnum * 3 + 0] == nx && mesh->data_normal3f[vnum * 3 + 1] == ny && mesh->data_normal3f[vnum * 3 + 2] == nz
         && mesh->data_texcoordtexture2f[vnum * 2 + 0] == s && mesh->data_texcoordtexture2f[vnum * 2 + 1] == t
         && mesh->data_texcoordlightmap2f[vnum * 2 + 0] == u && mesh->data_texcoordlightmap2f[vnum * 2 + 1] == v
         && mesh->data_lightmapcolor4f[vnum * 4 + 0] == r && mesh->data_lightmapcolor4f[vnum * 4 + 1] == g && mesh->data_lightmapcolor4f[vnum * 4 + 2] == b && mesh->data_lightmapcolor4f[vnum * 4 + 3] == a)
            return vnum;
    }
    // add the new vertex
    vnum = mesh->num_vertices++;
    if (surf->num_vertices > 0)
    {
        if (surf->mins[0] > x) surf->mins[0] = x;
        if (surf->mins[1] > y) surf->mins[1] = y;
        if (surf->mins[2] > z) surf->mins[2] = z;
        if (surf->maxs[0] < x) surf->maxs[0] = x;
        if (surf->maxs[1] < y) surf->maxs[1] = y;
        if (surf->maxs[2] < z) surf->maxs[2] = z;
    }
    else
    {
        VectorSet(surf->mins, x, y, z);
        VectorSet(surf->maxs, x, y, z);
    }
    surf->num_vertices = mesh->num_vertices - surf->num_firstvertex;
    mesh->data_vertexhash[h] = vnum;
    mesh->data_vertex3f[vnum * 3 + 0] = x;
    mesh->data_vertex3f[vnum * 3 + 1] = y;
    mesh->data_vertex3f[vnum * 3 + 2] = z;
    mesh->data_normal3f[vnum * 3 + 0] = nx;
    mesh->data_normal3f[vnum * 3 + 1] = ny;
    mesh->data_normal3f[vnum * 3 + 2] = nz;
    mesh->data_texcoordtexture2f[vnum * 2 + 0] = s;
    mesh->data_texcoordtexture2f[vnum * 2 + 1] = t;
    mesh->data_texcoordlightmap2f[vnum * 2 + 0] = u;
    mesh->data_texcoordlightmap2f[vnum * 2 + 1] = v;
    mesh->data_lightmapcolor4f[vnum * 4 + 0] = r;
    mesh->data_lightmapcolor4f[vnum * 4 + 1] = g;
    mesh->data_lightmapcolor4f[vnum * 4 + 2] = b;
    mesh->data_lightmapcolor4f[vnum * 4 + 3] = a;
    return vnum;
}

References a, b, surfmesh_t::data_lightmapcolor4f, surfmesh_t::data_normal3f, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordlightmap2f, surfmesh_t::data_texcoordtexture2f, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, surfmesh_t::data_vertexhash, g, int(), mask, max, surfmesh_t::max_vertices, msurface_t::maxs, Mem_Realloc, msurface_t::mins, mod(), msurface_t::num_firstvertex, surfmesh_t::num_vertexhashsize, msurface_t::num_vertices, surfmesh_t::num_vertices, r, v, VectorSet, x, y, and z.

Referenced by CL_Beam_AddQuad(), DrawQ_Line(), DrawQ_Pic(), DrawQ_RotPic(), DrawQ_String_Scale(), DrawQ_SuperPic(), R_DebugLine(), and VM_CL_R_PolygonEnd().

Mod_Mesh_Reset()

void Mod_Mesh_Reset

(

model_t *

mod

)

Definition at line 4465 of file model_shared.c.

{
    mod->num_surfaces = 0;
    mod->surfmesh.num_vertices = 0;
    mod->surfmesh.num_triangles = 0;
    if (mod->surfmesh.data_vertexhash) // UBSan: memset arg 1 isn't allowed to be null, but sometimes this is NULL.
        memset(mod->surfmesh.data_vertexhash, -1, mod->surfmesh.num_vertexhashsize * sizeof(*mod->surfmesh.data_vertexhash));
    mod->DrawSky = NULL; // will be set if a texture needs it
    mod->DrawAddWaterPlanes = NULL; // will be set if a texture needs it
}

References mod(), and NULL.

Referenced by CL_MeshEntities_Scene_Clear(), and DrawQ_FlushUI().

Mod_Mesh_Validate()

void Mod_Mesh_Validate

(

model_t *

mod

)

Definition at line 4736 of file model_shared.c.

{
    int i;
    qbool warned = false;
    for (i = 0; i < mod->num_surfaces; i++)
    {
        msurface_t *surf = mod->data_surfaces + i;
        int *e = mod->surfmesh.data_element3i + surf->num_firsttriangle * 3;
        int first = surf->num_firstvertex;
        int end = surf->num_firstvertex + surf->num_vertices;
        int j;
        for (j = 0;j < surf->num_triangles * 3;j++)
        {
            if (e[j] < first || e[j] >= end)
            {
                if (!warned)
                    Con_DPrintf(CON_WARN "Mod_Mesh_Validate: detected corrupt surface - debug me!\n");
                warned = true;
                e[j] = first;
            }
        }
    }
}

References Con_DPrintf(), CON_WARN, first, i, mod(), msurface_t::num_firsttriangle, msurface_t::num_firstvertex, msurface_t::num_triangles, and msurface_t::num_vertices.

Referenced by Mod_Mesh_Finalize().

Mod_OBJ_Load()

void Mod_OBJ_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 8417 of file model_brush.c.

{
    const char *textbase = (char *)buffer, *text = textbase;
    char *s;
    char *argv[512];
    char line[1024];
    char materialname[MAX_QPATH];
    int i, j, l, numvertices, firstvertex, firsttriangle, elementindex, vertexindex, surfacevertices, surfacetriangles, surfaceelements, submodelindex = 0;
    int index1, index2, index3;
    objvertex_t vfirst, vprev, vcurrent;
    int argc;
    int linelen;
    int numtriangles = 0;
    int maxtriangles = 0;
    objvertex_t *vertices = NULL;
    int linenumber = 0;
    int maxtextures = 0, numtextures = 0, textureindex = 0;
    int maxv = 0, numv = 1;
    int maxvt = 0, numvt = 1;
    int maxvn = 0, numvn = 1;
    char *texturenames = NULL;
    float dist, modelradius, modelyawradius, yawradius;
    float *obj_v = NULL;
    float *obj_vt = NULL;
    float *obj_vn = NULL;
    float mins[3];
    float maxs[3];
    float corner[3];
    objvertex_t *thisvertex = NULL;
    int vertexhashindex;
    int *vertexhashtable = NULL;
    objvertex_t *vertexhashdata = NULL;
    objvertex_t *vdata = NULL;
    int vertexhashsize = 0;
    int vertexhashcount = 0;
    skinfile_t *skinfiles = NULL;
    unsigned char *data = NULL;
    int *submodelfirstsurface;
    msurface_t *tempsurface;
    msurface_t *tempsurfaces;
 
    memset(&vfirst, 0, sizeof(vfirst));
    memset(&vprev, 0, sizeof(vprev));
    memset(&vcurrent, 0, sizeof(vcurrent));
 
    dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name);
 
    loadmodel->modeldatatypestring = "OBJ";
 
    loadmodel->type = mod_obj;
    loadmodel->soundfromcenter = true;
    loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
    loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
    loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
    loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
    loadmodel->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLine;
    loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    loadmodel->brush.TraceLineOfSight = NULL;
    loadmodel->brush.SuperContentsFromNativeContents = NULL;
    loadmodel->brush.NativeContentsFromSuperContents = NULL;
    loadmodel->brush.GetPVS = NULL;
    loadmodel->brush.FatPVS = NULL;
    loadmodel->brush.BoxTouchingPVS = NULL;
    loadmodel->brush.BoxTouchingLeafPVS = NULL;
    loadmodel->brush.BoxTouchingVisibleLeafs = NULL;
    loadmodel->brush.FindBoxClusters = NULL;
    loadmodel->brush.LightPoint = NULL;
    loadmodel->brush.FindNonSolidLocation = NULL;
    loadmodel->brush.AmbientSoundLevelsForPoint = NULL;
    loadmodel->brush.RoundUpToHullSize = NULL;
    loadmodel->brush.PointInLeaf = NULL;
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->GetLightInfo = R_Mod_GetLightInfo;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
 
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
 
    // make skinscenes for the skins (no groups)
    loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    VectorClear(mins);
    VectorClear(maxs);
 
    // we always have model 0, i.e. the first "submodel"
    loadmodel->brush.numsubmodels = 1;
 
    // parse the OBJ text now
    for(;;)
    {
        static char emptyarg[1] = "";
        if (!*text)
            break;
        linenumber++;
        linelen = 0;
        for (linelen = 0;text[linelen] && text[linelen] != '\r' && text[linelen] != '\n';linelen++)
            line[linelen] = text[linelen];
        line[linelen] = 0;
        for (argc = 0;argc < 4;argc++)
            argv[argc] = emptyarg;
        argc = 0;
        s = line;
        while (*s == ' ' || *s == '\t')
            s++;
        while (*s)
        {
            argv[argc++] = s;
            while (*s > ' ')
                s++;
            if (!*s)
                break;
            *s++ = 0;
            while (*s == ' ' || *s == '\t')
                s++;
        }
        text += linelen;
        if (*text == '\r')
            text++;
        if (*text == '\n')
            text++;
        if (!argc)
            continue;
        if (argv[0][0] == '#')
            continue;
        if (!strcmp(argv[0], "v"))
        {
            if (maxv <= numv)
            {
                maxv = max(maxv * 2, 1024);
                obj_v = (float *)Mem_Realloc(tempmempool, obj_v, maxv * sizeof(float[3]));
            }
            if(mod_obj_orientation.integer)
            {
                obj_v[numv*3+0] = atof(argv[1]);
                obj_v[numv*3+2] = atof(argv[2]);
                obj_v[numv*3+1] = atof(argv[3]);
            }
            else
            {
                obj_v[numv*3+0] = atof(argv[1]);
                obj_v[numv*3+1] = atof(argv[2]);
                obj_v[numv*3+2] = atof(argv[3]);
            }
            numv++;
        }
        else if (!strcmp(argv[0], "vt"))
        {
            if (maxvt <= numvt)
            {
                maxvt = max(maxvt * 2, 1024);
                obj_vt = (float *)Mem_Realloc(tempmempool, obj_vt, maxvt * sizeof(float[2]));
            }
            obj_vt[numvt*2+0] = atof(argv[1]);
            obj_vt[numvt*2+1] = 1-atof(argv[2]);
            numvt++;
        }
        else if (!strcmp(argv[0], "vn"))
        {
            if (maxvn <= numvn)
            {
                maxvn = max(maxvn * 2, 1024);
                obj_vn = (float *)Mem_Realloc(tempmempool, obj_vn, maxvn * sizeof(float[3]));
            }
            if(mod_obj_orientation.integer)
            {
                obj_vn[numvn*3+0] = atof(argv[1]);
                obj_vn[numvn*3+2] = atof(argv[2]);
                obj_vn[numvn*3+1] = atof(argv[3]);
            }
            else
            {
                obj_vn[numvn*3+0] = atof(argv[1]);
                obj_vn[numvn*3+1] = atof(argv[2]);
                obj_vn[numvn*3+2] = atof(argv[3]);
            }
            numvn++;
        }
        else if (!strcmp(argv[0], "f"))
        {
            if (!numtextures)
            {
                if (maxtextures <= numtextures)
                {
                    maxtextures = max(maxtextures * 2, 256);
                    texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH);
                }
                textureindex = numtextures++;
                dp_strlcpy(texturenames + textureindex*MAX_QPATH, loadmodel->name, MAX_QPATH);
            }
            for (j = 1;j < argc;j++)
            {
                index1 = atoi(argv[j]);
                while(argv[j][0] && argv[j][0] != '/')
                    argv[j]++;
                if (argv[j][0])
                    argv[j]++;
                index2 = atoi(argv[j]);
                while(argv[j][0] && argv[j][0] != '/')
                    argv[j]++;
                if (argv[j][0])
                    argv[j]++;
                index3 = atoi(argv[j]);
                // negative refers to a recent vertex
                // zero means not specified
                // positive means an absolute vertex index
                if (index1 < 0)
                    index1 = numv - index1;
                if (index2 < 0)
                    index2 = numvt - index2;
                if (index3 < 0)
                    index3 = numvn - index3;
                vcurrent.nextindex = -1;
                vcurrent.textureindex = textureindex;
                vcurrent.submodelindex = submodelindex;
                if (obj_v && index1 >= 0 && index1 < numv)
                    VectorCopy(obj_v + 3*index1, vcurrent.v);
                if (obj_vt && index2 >= 0 && index2 < numvt)
                    Vector2Copy(obj_vt + 2*index2, vcurrent.vt);
                if (obj_vn && index3 >= 0 && index3 < numvn)
                    VectorCopy(obj_vn + 3*index3, vcurrent.vn);
                if (numtriangles == 0)
                {
                    VectorCopy(vcurrent.v, mins);
                    VectorCopy(vcurrent.v, maxs);
                }
                else
                {
                    mins[0] = min(mins[0], vcurrent.v[0]);
                    mins[1] = min(mins[1], vcurrent.v[1]);
                    mins[2] = min(mins[2], vcurrent.v[2]);
                    maxs[0] = max(maxs[0], vcurrent.v[0]);
                    maxs[1] = max(maxs[1], vcurrent.v[1]);
                    maxs[2] = max(maxs[2], vcurrent.v[2]);
                }
                if (j == 1)
                    vfirst = vcurrent;
                else if (j >= 3)
                {
                    if (maxtriangles <= numtriangles)
                    {
                        maxtriangles = max(maxtriangles * 2, 32768);
                        vertices = (objvertex_t*)Mem_Realloc(loadmodel->mempool, vertices, maxtriangles * sizeof(objvertex_t[3]));
                    }
                    if(mod_obj_orientation.integer)
                    {
                        vertices[numtriangles*3+0] = vfirst;
                        vertices[numtriangles*3+1] = vprev;
                        vertices[numtriangles*3+2] = vcurrent;
                    }
                    else
                    {
                        vertices[numtriangles*3+0] = vfirst;
                        vertices[numtriangles*3+2] = vprev;
                        vertices[numtriangles*3+1] = vcurrent;
                    }
                    numtriangles++;
                }
                vprev = vcurrent;
            }
        }
        else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g"))
        {
            submodelindex = atof(argv[1]);
            loadmodel->brush.numsubmodels = max(submodelindex + 1, loadmodel->brush.numsubmodels);
        }
        else if (!strcmp(argv[0], "usemtl"))
        {
            for (i = 0;i < numtextures;i++)
                if (!strcmp(texturenames+i*MAX_QPATH, argv[1]))
                    break;
            if (i < numtextures)
                textureindex = i;
            else
            {
                if (maxtextures <= numtextures)
                {
                    maxtextures = max(maxtextures * 2, 256);
                    texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH);
                }
                textureindex = numtextures++;
                dp_strlcpy(texturenames + textureindex*MAX_QPATH, argv[1], MAX_QPATH);
            }
        }
    }
 
    // now that we have the OBJ data loaded as-is, we can convert it
 
    // copy the model bounds, then enlarge the yaw and rotated bounds according to radius
    VectorCopy(mins, loadmodel->normalmins);
    VectorCopy(maxs, loadmodel->normalmaxs);
    dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0]));
    modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1]));
    modelyawradius = dist*dist+modelyawradius*modelyawradius;
    modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2]));
    modelradius = modelyawradius + modelradius * modelradius;
    modelyawradius = sqrt(modelyawradius);
    modelradius = sqrt(modelradius);
    loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius;
    loadmodel->yawmins[2] = loadmodel->normalmins[2];
    loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] =  modelyawradius;
    loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
    loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius;
    loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] =  modelradius;
    loadmodel->radius = modelradius;
    loadmodel->radius2 = modelradius * modelradius;
 
    // allocate storage for triangles
    loadmodel->surfmesh.data_element3i = (int *)Mem_Alloc(loadmodel->mempool, numtriangles * sizeof(int[3]));
    // allocate vertex hash structures to build an optimal vertex subset
    vertexhashsize = numtriangles*2;
    vertexhashtable = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int) * vertexhashsize);
    memset(vertexhashtable, 0xFF, sizeof(int) * vertexhashsize);
    vertexhashdata = (objvertex_t *)Mem_Alloc(loadmodel->mempool, sizeof(*vertexhashdata) * numtriangles*3);
    vertexhashcount = 0;
 
    // gather surface stats for assigning vertex/triangle ranges
    firstvertex = 0;
    firsttriangle = 0;
    elementindex = 0;
    loadmodel->num_surfaces = 0;
    // allocate storage for the worst case number of surfaces, later we resize
    tempsurfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, numtextures * loadmodel->brush.numsubmodels * sizeof(msurface_t));
    submodelfirstsurface = (int *)Mem_Alloc(loadmodel->mempool, (loadmodel->brush.numsubmodels+1) * sizeof(int));
    tempsurface = tempsurfaces;
    for (submodelindex = 0;submodelindex < loadmodel->brush.numsubmodels;submodelindex++)
    {
        submodelfirstsurface[submodelindex] = loadmodel->num_surfaces;
        for (textureindex = 0;textureindex < numtextures;textureindex++)
        {
            for (vertexindex = 0;vertexindex < numtriangles*3;vertexindex++)
            {
                thisvertex = vertices + vertexindex;
                if (thisvertex->submodelindex == submodelindex && thisvertex->textureindex == textureindex)
                    break;
            }
            // skip the surface creation if there are no triangles for it
            if (vertexindex == numtriangles*3)
                continue;
            // create a surface for these vertices
            surfacevertices = 0;
            surfaceelements = 0;
            // we hack in a texture index in the surface to be fixed up later...
            tempsurface->texture = (texture_t *)((size_t)textureindex);
            // calculate bounds as we go
            VectorCopy(thisvertex->v, tempsurface->mins);
            VectorCopy(thisvertex->v, tempsurface->maxs);
            for (;vertexindex < numtriangles*3;vertexindex++)
            {
                thisvertex = vertices + vertexindex;
                if (thisvertex->submodelindex != submodelindex)
                    continue;
                if (thisvertex->textureindex != textureindex)
                    continue;
                // add vertex to surface bounds
                tempsurface->mins[0] = min(tempsurface->mins[0], thisvertex->v[0]);
                tempsurface->mins[1] = min(tempsurface->mins[1], thisvertex->v[1]);
                tempsurface->mins[2] = min(tempsurface->mins[2], thisvertex->v[2]);
                tempsurface->maxs[0] = max(tempsurface->maxs[0], thisvertex->v[0]);
                tempsurface->maxs[1] = max(tempsurface->maxs[1], thisvertex->v[1]);
                tempsurface->maxs[2] = max(tempsurface->maxs[2], thisvertex->v[2]);
                // add the vertex if it is not found in the merged set, and
                // get its index (triangle element) for the surface
                vertexhashindex = (unsigned int)(thisvertex->v[0] * 3571 + thisvertex->v[0] * 1777 + thisvertex->v[0] * 457) % (unsigned int)vertexhashsize;
                for (i = vertexhashtable[vertexhashindex];i >= 0;i = vertexhashdata[i].nextindex)
                {
                    vdata = vertexhashdata + i;
                    if (vdata->submodelindex == thisvertex->submodelindex && vdata->textureindex == thisvertex->textureindex && VectorCompare(thisvertex->v, vdata->v) && VectorCompare(thisvertex->vn, vdata->vn) && Vector2Compare(thisvertex->vt, vdata->vt))
                        break;
                }
                if (i < 0)
                {
                    i = vertexhashcount++;
                    vdata = vertexhashdata + i;
                    *vdata = *thisvertex;
                    vdata->nextindex = vertexhashtable[vertexhashindex];
                    vertexhashtable[vertexhashindex] = i;
                    surfacevertices++;
                }
                loadmodel->surfmesh.data_element3i[elementindex++] = i;
                surfaceelements++;
            }
            surfacetriangles = surfaceelements / 3;
            tempsurface->num_vertices = surfacevertices;
            tempsurface->num_triangles = surfacetriangles;
            tempsurface->num_firstvertex = firstvertex;
            tempsurface->num_firsttriangle = firsttriangle;
            firstvertex += tempsurface->num_vertices;
            firsttriangle += tempsurface->num_triangles;
            tempsurface++;
            loadmodel->num_surfaces++;
        }
    }
    submodelfirstsurface[submodelindex] = loadmodel->num_surfaces;
    numvertices = firstvertex;
    loadmodel->data_surfaces = (msurface_t *)Mem_Realloc(loadmodel->mempool, tempsurfaces, loadmodel->num_surfaces * sizeof(msurface_t));
    tempsurfaces = NULL;
 
    // allocate storage for final mesh data
    loadmodel->num_textures = numtextures * loadmodel->numskins;
    loadmodel->num_texturesperskin = numtextures;
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + numtriangles * sizeof(int[3]) + (numvertices <= 65536 ? numtriangles * sizeof(unsigned short[3]) : 0) + numvertices * sizeof(float[14]) + loadmodel->brush.numsubmodels * sizeof(model_t *));
    loadmodel->brush.submodels = (model_t **)data;data += loadmodel->brush.numsubmodels * sizeof(model_t *);
    loadmodel->modelsurfaces_sorted = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->data_textures = (texture_t *)data;data += loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t);
    loadmodel->surfmesh.num_vertices = numvertices;
    loadmodel->surfmesh.num_triangles = numtriangles;
    loadmodel->surfmesh.data_vertex3f = (float *)data;data += numvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_svector3f = (float *)data;data += numvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_tvector3f = (float *)data;data += numvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_normal3f = (float *)data;data += numvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += numvertices * sizeof(float[2]);
 
    if (loadmodel->surfmesh.num_vertices <= 65536) {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
    }
 
    for (j = 0;j < loadmodel->surfmesh.num_vertices;j++)
    {
        VectorCopy(vertexhashdata[j].v, loadmodel->surfmesh.data_vertex3f + 3*j);
        VectorCopy(vertexhashdata[j].vn, loadmodel->surfmesh.data_normal3f + 3*j);
        Vector2Copy(vertexhashdata[j].vt, loadmodel->surfmesh.data_texcoordtexture2f + 2*j);
    }
 
    // load the textures
    for (textureindex = 0;textureindex < numtextures;textureindex++)
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + textureindex, skinfiles, texturenames + textureindex*MAX_QPATH, texturenames + textureindex*MAX_QPATH);
    Mod_FreeSkinFiles(skinfiles);
 
    // set the surface textures to their real values now that we loaded them...
    for (i = 0;i < loadmodel->num_surfaces;i++)
        loadmodel->data_surfaces[i].texture = loadmodel->data_textures + (size_t)loadmodel->data_surfaces[i].texture;
 
    // free data
    Mem_Free(vertices);
    Mem_Free(texturenames);
    Mem_Free(obj_v);
    Mem_Free(obj_vt);
    Mem_Free(obj_vn);
    Mem_Free(vertexhashtable);
    Mem_Free(vertexhashdata);
 
    // compute all the mesh information that was not loaded from the file
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
    Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
    // generate normals if the file did not have them
    if (!VectorLength2(loadmodel->surfmesh.data_normal3f))
        Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0);
    Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0);
 
    // if this is a worldmodel and has no BSP tree, create a fake one for the purpose
    loadmodel->brush.num_visleafs = 1;
    loadmodel->brush.num_leafs = 1;
    loadmodel->brush.num_nodes = 0;
    loadmodel->brush.num_leafsurfaces = loadmodel->num_surfaces;
    loadmodel->brush.data_leafs = (mleaf_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafs * sizeof(mleaf_t));
    loadmodel->brush.data_nodes = (mnode_t *)loadmodel->brush.data_leafs;
    loadmodel->brush.num_pvsclusters = 1;
    loadmodel->brush.num_pvsclusterbytes = 1;
    loadmodel->brush.data_pvsclusters = nobsp_pvs;
    //if (loadmodel->num_nodes) loadmodel->data_nodes = (mnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_nodes * sizeof(mnode_t));
    //loadmodel->data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->num_leafsurfaces * sizeof(int));
    loadmodel->brush.data_leafsurfaces = loadmodel->modelsurfaces_sorted;
    VectorCopy(loadmodel->normalmins, loadmodel->brush.data_leafs->mins);
    VectorCopy(loadmodel->normalmaxs, loadmodel->brush.data_leafs->maxs);
    loadmodel->brush.data_leafs->combinedsupercontents = 0; // FIXME?
    loadmodel->brush.data_leafs->clusterindex = 0;
    loadmodel->brush.data_leafs->areaindex = 0;
    loadmodel->brush.data_leafs->numleafsurfaces = loadmodel->brush.num_leafsurfaces;
    loadmodel->brush.data_leafs->firstleafsurface = loadmodel->brush.data_leafsurfaces;
    loadmodel->brush.data_leafs->numleafbrushes = 0;
    loadmodel->brush.data_leafs->firstleafbrush = NULL;
    loadmodel->brush.supportwateralpha = true;
 
    if (loadmodel->brush.numsubmodels)
        loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
 
    mod = loadmodel;
    for (i = 0;i < loadmodel->brush.numsubmodels;i++)
    {
        if (i > 0)
        {
            char name[10];
            // duplicate the basic information
            dpsnprintf(name, sizeof(name), "*%i", i);
            mod = Mod_FindName(name, loadmodel->name);
            // copy the base model to this one
            *mod = *loadmodel;
            // rename the clone back to its proper name
            dp_strlcpy(mod->name, name, sizeof(mod->name));
            mod->brush.parentmodel = loadmodel;
            // textures and memory belong to the main model
            mod->texturepool = NULL;
            mod->mempool = NULL;
            mod->brush.GetPVS = NULL;
            mod->brush.FatPVS = NULL;
            mod->brush.BoxTouchingPVS = NULL;
            mod->brush.BoxTouchingLeafPVS = NULL;
            mod->brush.BoxTouchingVisibleLeafs = NULL;
            mod->brush.FindBoxClusters = NULL;
            mod->brush.LightPoint = NULL;
            mod->brush.AmbientSoundLevelsForPoint = NULL;
        }
        mod->brush.submodel = i;
        if (loadmodel->brush.submodels)
            loadmodel->brush.submodels[i] = mod;
 
        // make the model surface list (used by shadowing/lighting)
        mod->submodelsurfaces_start = submodelfirstsurface[i];
        mod->submodelsurfaces_end = submodelfirstsurface[i+1];
        mod->firstmodelbrush = 0;
        mod->nummodelbrushes = 0;
 
        VectorClear(mod->normalmins);
        VectorClear(mod->normalmaxs);
        l = false;
        for (j = mod->submodelsurfaces_start;j < mod->submodelsurfaces_end;j++)
        {
            const msurface_t *surface = mod->data_surfaces + j;
            const float *v3f = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex;
            int k;
            if (!surface->num_vertices)
                continue;
            if (!l)
            {
                l = true;
                VectorCopy(v3f, mod->normalmins);
                VectorCopy(v3f, mod->normalmaxs);
            }
            for (k = 0;k < surface->num_vertices;k++, v3f += 3)
            {
                mod->normalmins[0] = min(mod->normalmins[0], v3f[0]);
                mod->normalmins[1] = min(mod->normalmins[1], v3f[1]);
                mod->normalmins[2] = min(mod->normalmins[2], v3f[2]);
                mod->normalmaxs[0] = max(mod->normalmaxs[0], v3f[0]);
                mod->normalmaxs[1] = max(mod->normalmaxs[1], v3f[1]);
                mod->normalmaxs[2] = max(mod->normalmaxs[2], v3f[2]);
            }
        }
        corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
        corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
        corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
        modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]);
        yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]);
        mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
        mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
        mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius;
        mod->yawmins[0] = mod->yawmins[1] = -yawradius;
        mod->yawmins[2] = mod->normalmins[2];
        mod->yawmaxs[2] = mod->normalmaxs[2];
        mod->radius = modelradius;
        mod->radius2 = modelradius * modelradius;
 
        Mod_SetDrawSkyAndWater(mod);
 
        Mod_MakeCollisionBIH(mod, true, &mod->collision_bih);
        mod->render_bih = mod->collision_bih;
 
        // generate VBOs and other shared data before cloning submodels
        if (i == 0)
            Mod_BuildVBOs();
    }
    mod = loadmodel;
    Mem_Free(submodelfirstsurface);
 
    // make the model surface list (used by shadowing/lighting)
    Mod_MakeSortedSurfaces(loadmodel);
 
    Con_DPrintf("Stats for obj model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces);
}

References model_brush_t::AmbientSoundLevelsForPoint, mleaf_t::areaindex, argv(), model_brush_t::BoxTouchingLeafPVS, model_brush_t::BoxTouchingPVS, model_brush_t::BoxTouchingVisibleLeafs, model_t::brush, buffer, mleaf_t::clusterindex, mleaf_t::combinedsupercontents, model_t::CompileShadowMap, Con_DPrintf(), data, surfmesh_t::data_element3i, surfmesh_t::data_element3s, model_brush_t::data_leafs, model_brush_t::data_leafsurfaces, model_brush_t::data_nodes, surfmesh_t::data_normal3f, model_brush_t::data_pvsclusters, model_t::data_surfaces, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, dp_strlcpy, dpsnprintf(), model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, fabs(), model_brush_t::FatPVS, model_brush_t::FindBoxClusters, model_brush_t::FindNonSolidLocation, animscene_t::firstframe, mleaf_t::firstleafbrush, mleaf_t::firstleafsurface, animscene_t::framecount, animscene_t::framerate, model_t::GetLightInfo, model_brush_t::GetPVS, i, int(), cvar_t::integer, model_brush_t::LightPoint, loadmodel, animscene_t::loop, max, MAX_QPATH, maxs, mleaf_t::maxs, msurface_t::maxs, Mem_Alloc, Mem_Free, Mem_Realloc, model_t::mempool, min, mins, mleaf_t::mins, msurface_t::mins, mod(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildNormals(), Mod_BuildTextureVectorsFromNormals(), Mod_BuildVBOs(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FindName(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), mod_obj, mod_obj_orientation, Mod_SetDrawSkyAndWater(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, model_t::name, name, model_brush_t::NativeContentsFromSuperContents, objvertex_t::nextindex, nobsp_pvs, model_t::normalmaxs, model_t::normalmins, NULL, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, model_brush_t::num_leafs, model_brush_t::num_leafsurfaces, model_brush_t::num_nodes, model_brush_t::num_portals, model_brush_t::num_pvsclusterbytes, model_brush_t::num_pvsclusters, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, msurface_t::num_vertices, surfmesh_t::num_vertices, model_brush_t::num_visleafs, mleaf_t::numleafbrushes, mleaf_t::numleafsurfaces, model_t::numskins, model_brush_t::numsubmodels, model_brush_t::PointInLeaf, model_t::PointSuperContents, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), R_Mod_GetLightInfo(), r_smoothnormals_areaweighting, model_t::radius, model_t::radius2, model_t::rotatedmaxs, model_t::rotatedmins, model_brush_t::RoundUpToHullSize, model_t::skinscenes, model_t::soundfromcenter, sqrt(), objvertex_t::submodelindex, model_brush_t::submodels, model_brush_t::SuperContentsFromNativeContents, model_brush_t::supportwateralpha, model_t::surfmesh, tempmempool, msurface_t::texture, objvertex_t::textureindex, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TraceLineAgainstSurfaces, model_brush_t::TraceLineOfSight, model_t::TracePoint, model_t::type, objvertex_t::v, v, Vector2Compare, Vector2Copy, VectorClear, VectorCompare, VectorCopy, VectorLength2, objvertex_t::vn, objvertex_t::vt, model_t::yawmaxs, and model_t::yawmins.

Mod_PSKMODEL_Load()

void Mod_PSKMODEL_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 2540 of file model_alias.c.

{
    int i, j, index, version, recordsize, numrecords, meshvertices, meshtriangles;
    int numpnts, numvtxw, numfaces, nummatts, numbones, numrawweights, numanimbones, numanims, numanimkeys;
    fs_offset_t filesize;
    pskpnts_t *pnts;
    pskvtxw_t *vtxw;
    pskface_t *faces;
    pskmatt_t *matts;
    pskboneinfo_t *bones;
    pskrawweights_t *rawweights;
    //pskboneinfo_t *animbones;
    pskaniminfo_t *anims;
    pskanimkeys_t *animkeys;
    void *animfilebuffer, *animbuffer, *animbufferend;
    unsigned char *data;
    pskchunk_t *pchunk;
    skinfile_t *skinfiles;
    char animname[MAX_QPATH];
    float biggestorigin;
 
    pchunk = (pskchunk_t *)buffer;
    if (strcmp(pchunk->id, "ACTRHEAD"))
        Host_Error ("Mod_PSKMODEL_Load: %s is not an Unreal Engine ActorX (.psk + .psa) model", loadmodel->name);
 
    loadmodel->modeldatatypestring = "PSK";
 
    loadmodel->type = mod_alias;
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
    loadmodel->synctype = ST_RAND;
 
    FS_StripExtension(loadmodel->name, animname, sizeof(animname));
    dp_strlcat(animname, ".psa", sizeof(animname));
    animbuffer = animfilebuffer = FS_LoadFile(animname, loadmodel->mempool, false, &filesize);
    animbufferend = (void *)((unsigned char*)animbuffer + (int)filesize);
    if (!animbuffer)
        animbufferend = animbuffer;
 
    numpnts = 0;
    pnts = NULL;
    numvtxw = 0;
    vtxw = NULL;
    numfaces = 0;
    faces = NULL;
    nummatts = 0;
    matts = NULL;
    numbones = 0;
    bones = NULL;
    numrawweights = 0;
    rawweights = NULL;
    numanims = 0;
    anims = NULL;
    numanimkeys = 0;
    animkeys = NULL;
 
    while (buffer < bufferend)
    {
        pchunk = (pskchunk_t *)buffer;
        buffer = (void *)((unsigned char *)buffer + sizeof(pskchunk_t));
        version = LittleLong(pchunk->version);
        recordsize = LittleLong(pchunk->recordsize);
        numrecords = LittleLong(pchunk->numrecords);
        if (developer_extra.integer)
            Con_DPrintf("%s: %s %x: %i * %i = %i\n", loadmodel->name, pchunk->id, version, recordsize, numrecords, recordsize * numrecords);
        if (version != 0x1e83b9 && version != 0x1e9179 && version != 0x2e && version != 0x12f2bc && version != 0x12f2f0)
            Con_Printf ("%s: chunk %s has unknown version %x (0x1e83b9, 0x1e9179, 0x2e, 0x12f2bc, 0x12f2f0 are currently supported), trying to load anyway!\n", loadmodel->name, pchunk->id, version);
        if (!strcmp(pchunk->id, "ACTRHEAD"))
        {
            // nothing to do
        }
        else if (!strcmp(pchunk->id, "PNTS0000"))
        {
            pskpnts_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            numpnts = numrecords;
            pnts = (pskpnts_t *)buffer;
            for (index = 0, p = (pskpnts_t *)buffer;index < numrecords;index++, p++)
            {
                p->origin[0] = LittleFloat(p->origin[0]);
                p->origin[1] = LittleFloat(p->origin[1]);
                p->origin[2] = LittleFloat(p->origin[2]);
            }
            buffer = p;
        }
        else if (!strcmp(pchunk->id, "VTXW0000"))
        {
            pskvtxw_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            numvtxw = numrecords;
            vtxw = (pskvtxw_t *)buffer;
            for (index = 0, p = (pskvtxw_t *)buffer;index < numrecords;index++, p++)
            {
                p->pntsindex = LittleShort(p->pntsindex);
                p->texcoord[0] = LittleFloat(p->texcoord[0]);
                p->texcoord[1] = LittleFloat(p->texcoord[1]);
                if (p->pntsindex >= numpnts)
                {
                    Con_Printf("%s: vtxw->pntsindex %i >= numpnts %i\n", loadmodel->name, p->pntsindex, numpnts);
                    p->pntsindex = 0;
                }
            }
            buffer = p;
        }
        else if (!strcmp(pchunk->id, "FACE0000"))
        {
            pskface_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            numfaces = numrecords;
            faces = (pskface_t *)buffer;
            for (index = 0, p = (pskface_t *)buffer;index < numrecords;index++, p++)
            {
                p->vtxwindex[0] = LittleShort(p->vtxwindex[0]);
                p->vtxwindex[1] = LittleShort(p->vtxwindex[1]);
                p->vtxwindex[2] = LittleShort(p->vtxwindex[2]);
                p->group = LittleLong(p->group);
                if (p->vtxwindex[0] >= numvtxw)
                {
                    Con_Printf("%s: face->vtxwindex[0] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[0], numvtxw);
                    p->vtxwindex[0] = 0;
                }
                if (p->vtxwindex[1] >= numvtxw)
                {
                    Con_Printf("%s: face->vtxwindex[1] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[1], numvtxw);
                    p->vtxwindex[1] = 0;
                }
                if (p->vtxwindex[2] >= numvtxw)
                {
                    Con_Printf("%s: face->vtxwindex[2] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[2], numvtxw);
                    p->vtxwindex[2] = 0;
                }
            }
            buffer = p;
        }
        else if (!strcmp(pchunk->id, "MATT0000"))
        {
            pskmatt_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            nummatts = numrecords;
            matts = (pskmatt_t *)buffer;
            for (index = 0, p = (pskmatt_t *)buffer;index < numrecords;index++, p++)
            {
                // nothing to do
            }
            buffer = p;
        }
        else if (!strcmp(pchunk->id, "REFSKELT"))
        {
            pskboneinfo_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            numbones = numrecords;
            bones = (pskboneinfo_t *)buffer;
            for (index = 0, p = (pskboneinfo_t *)buffer;index < numrecords;index++, p++)
            {
                p->numchildren = LittleLong(p->numchildren);
                p->parent = LittleLong(p->parent);
                p->basepose.quat[0] = LittleFloat(p->basepose.quat[0]);
                p->basepose.quat[1] = LittleFloat(p->basepose.quat[1]);
                p->basepose.quat[2] = LittleFloat(p->basepose.quat[2]);
                p->basepose.quat[3] = LittleFloat(p->basepose.quat[3]);
                p->basepose.origin[0] = LittleFloat(p->basepose.origin[0]);
                p->basepose.origin[1] = LittleFloat(p->basepose.origin[1]);
                p->basepose.origin[2] = LittleFloat(p->basepose.origin[2]);
                p->basepose.unknown = LittleFloat(p->basepose.unknown);
                p->basepose.size[0] = LittleFloat(p->basepose.size[0]);
                p->basepose.size[1] = LittleFloat(p->basepose.size[1]);
                p->basepose.size[2] = LittleFloat(p->basepose.size[2]);
#ifdef PSKQUATNEGATIONS
                if (index)
                {
                    p->basepose.quat[0] *= -1;
                    p->basepose.quat[1] *= -1;
                    p->basepose.quat[2] *= -1;
                }
                else
                {
                    p->basepose.quat[0] *=  1;
                    p->basepose.quat[1] *= -1;
                    p->basepose.quat[2] *=  1;
                }
#endif
                if (p->parent < 0 || p->parent >= numbones)
                {
                    Con_Printf("%s: bone->parent %i >= numbones %i\n", loadmodel->name, p->parent, numbones);
                    p->parent = 0;
                }
            }
            buffer = p;
        }
        else if (!strcmp(pchunk->id, "RAWWEIGHTS"))
        {
            pskrawweights_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
            // byteswap in place and keep the pointer
            numrawweights = numrecords;
            rawweights = (pskrawweights_t *)buffer;
            for (index = 0, p = (pskrawweights_t *)buffer;index < numrecords;index++, p++)
            {
                p->weight = LittleFloat(p->weight);
                p->pntsindex = LittleLong(p->pntsindex);
                p->boneindex = LittleLong(p->boneindex);
                if (p->pntsindex < 0 || p->pntsindex >= numpnts)
                {
                    Con_Printf("%s: weight->pntsindex %i >= numpnts %i\n", loadmodel->name, p->pntsindex, numpnts);
                    p->pntsindex = 0;
                }
                if (p->boneindex < 0 || p->boneindex >= numbones)
                {
                    Con_Printf("%s: weight->boneindex %i >= numbones %i\n", loadmodel->name, p->boneindex, numbones);
                    p->boneindex = 0;
                }
            }
            buffer = p;
        }
    }
 
    while (animbuffer < animbufferend)
    {
        pchunk = (pskchunk_t *)animbuffer;
        animbuffer = (void *)((unsigned char *)animbuffer + sizeof(pskchunk_t));
        version = LittleLong(pchunk->version);
        recordsize = LittleLong(pchunk->recordsize);
        numrecords = LittleLong(pchunk->numrecords);
        if (developer_extra.integer)
            Con_DPrintf("%s: %s %x: %i * %i = %i\n", animname, pchunk->id, version, recordsize, numrecords, recordsize * numrecords);
        if (version != 0x1e83b9 && version != 0x1e9179 && version != 0x2e && version != 0x12f2bc && version != 0x12f2f0)
            Con_Printf ("%s: chunk %s has unknown version %x (0x1e83b9, 0x1e9179, 0x2e, 0x12f2bc, 0x12f2f0 are currently supported), trying to load anyway!\n", animname, pchunk->id, version);
        if (!strcmp(pchunk->id, "ANIMHEAD"))
        {
            // nothing to do
        }
        else if (!strcmp(pchunk->id, "BONENAMES"))
        {
            pskboneinfo_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
            // byteswap in place and keep the pointer
            numanimbones = numrecords;
            //animbones = (pskboneinfo_t *)animbuffer;
            // NOTE: supposedly psa does not need to match the psk model, the
            // bones missing from the psa would simply use their base
            // positions from the psk, but this is hard for me to implement
            // and people can easily make animations that match.
            if (numanimbones != numbones)
                Host_Error("%s: this loader only supports animations with the same bones as the mesh", loadmodel->name);
            for (index = 0, p = (pskboneinfo_t *)animbuffer;index < numrecords;index++, p++)
            {
                p->numchildren = LittleLong(p->numchildren);
                p->parent = LittleLong(p->parent);
                p->basepose.quat[0] = LittleFloat(p->basepose.quat[0]);
                p->basepose.quat[1] = LittleFloat(p->basepose.quat[1]);
                p->basepose.quat[2] = LittleFloat(p->basepose.quat[2]);
                p->basepose.quat[3] = LittleFloat(p->basepose.quat[3]);
                p->basepose.origin[0] = LittleFloat(p->basepose.origin[0]);
                p->basepose.origin[1] = LittleFloat(p->basepose.origin[1]);
                p->basepose.origin[2] = LittleFloat(p->basepose.origin[2]);
                p->basepose.unknown = LittleFloat(p->basepose.unknown);
                p->basepose.size[0] = LittleFloat(p->basepose.size[0]);
                p->basepose.size[1] = LittleFloat(p->basepose.size[1]);
                p->basepose.size[2] = LittleFloat(p->basepose.size[2]);
#ifdef PSKQUATNEGATIONS
                if (index)
                {
                    p->basepose.quat[0] *= -1;
                    p->basepose.quat[1] *= -1;
                    p->basepose.quat[2] *= -1;
                }
                else
                {
                    p->basepose.quat[0] *=  1;
                    p->basepose.quat[1] *= -1;
                    p->basepose.quat[2] *=  1;
                }
#endif
                if (p->parent < 0 || p->parent >= numanimbones)
                {
                    Con_Printf("%s: bone->parent %i >= numanimbones %i\n", animname, p->parent, numanimbones);
                    p->parent = 0;
                }
                // check that bones are the same as in the base
                if (strcmp(p->name, bones[index].name) || p->parent != bones[index].parent)
                    Host_Error("%s: this loader only supports animations with the same bones as the mesh", animname);
            }
            animbuffer = p;
        }
        else if (!strcmp(pchunk->id, "ANIMINFO"))
        {
            pskaniminfo_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
            // byteswap in place and keep the pointer
            numanims = numrecords;
            anims = (pskaniminfo_t *)animbuffer;
            for (index = 0, p = (pskaniminfo_t *)animbuffer;index < numrecords;index++, p++)
            {
                p->numbones = LittleLong(p->numbones);
                p->playtime = LittleFloat(p->playtime);
                p->fps = LittleFloat(p->fps);
                p->firstframe = LittleLong(p->firstframe);
                p->numframes = LittleLong(p->numframes);
                if (p->numbones != numbones)
                    Con_Printf("%s: animinfo->numbones != numbones, trying to load anyway!\n", animname);
            }
            animbuffer = p;
        }
        else if (!strcmp(pchunk->id, "ANIMKEYS"))
        {
            pskanimkeys_t *p;
            if (recordsize != sizeof(*p))
                Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
            numanimkeys = numrecords;
            animkeys = (pskanimkeys_t *)animbuffer;
            for (index = 0, p = (pskanimkeys_t *)animbuffer;index < numrecords;index++, p++)
            {
                p->origin[0] = LittleFloat(p->origin[0]);
                p->origin[1] = LittleFloat(p->origin[1]);
                p->origin[2] = LittleFloat(p->origin[2]);
                p->quat[0] = LittleFloat(p->quat[0]);
                p->quat[1] = LittleFloat(p->quat[1]);
                p->quat[2] = LittleFloat(p->quat[2]);
                p->quat[3] = LittleFloat(p->quat[3]);
                p->frametime = LittleFloat(p->frametime);
#ifdef PSKQUATNEGATIONS
                if (index % numbones)
                {
                    p->quat[0] *= -1;
                    p->quat[1] *= -1;
                    p->quat[2] *= -1;
                }
                else
                {
                    p->quat[0] *=  1;
                    p->quat[1] *= -1;
                    p->quat[2] *=  1;
                }
#endif
            }
            animbuffer = p;
            // TODO: allocate bonepose stuff
        }
        else
            Con_Printf("%s: unknown chunk ID \"%s\"\n", animname, pchunk->id);
    }
 
    if (!numpnts || !pnts || !numvtxw || !vtxw || !numfaces || !faces || !nummatts || !matts || !numbones || !bones || !numrawweights || !rawweights)
        Host_Error("%s: missing required chunks", loadmodel->name);
 
    if (numanims)
    {
        loadmodel->numframes = 0;
        for (index = 0;index < numanims;index++)
            loadmodel->numframes += anims[index].numframes;
        if (numanimkeys != numbones * loadmodel->numframes)
            Host_Error("%s: %s has incorrect number of animation keys", animname, pchunk->id);
    }
    else
        loadmodel->numframes = loadmodel->num_poses = 1;
 
    meshvertices = numvtxw;
    meshtriangles = numfaces;
 
    // load external .skin files if present
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
    loadmodel->num_bones = numbones;
    loadmodel->num_poses = loadmodel->numframes;
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces = nummatts;
    loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
    loadmodel->num_texturesperskin = loadmodel->num_surfaces;
    loadmodel->surfmesh.num_vertices = meshvertices;
    loadmodel->surfmesh.num_triangles = meshtriangles;
 
    // do most allocations as one merged chunk
    // This is only robust for C standard types!
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool,
        loadmodel->surfmesh.num_vertices * sizeof(float[3])
        + loadmodel->surfmesh.num_vertices * sizeof(float[3])
        + loadmodel->surfmesh.num_vertices * sizeof(float[3])
        + loadmodel->surfmesh.num_vertices * sizeof(float[3])
        + loadmodel->surfmesh.num_vertices * sizeof(float[2])
        + loadmodel->num_bones * sizeof(float[12])
        + loadmodel->num_surfaces * sizeof(int)
        + loadmodel->surfmesh.num_triangles * sizeof(int[3])
        + loadmodel->surfmesh.num_vertices * sizeof(unsigned short)
        + ((loadmodel->surfmesh.num_vertices <= 65536) ? (loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3])) : 0)
        + loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7])
        + loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4])
        + loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]));
    // Pointers must be taken in descending order of alignment requirement!
    loadmodel->surfmesh.data_vertex3f          = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_svector3f         = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_tvector3f         = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_normal3f          = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)data; data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
    loadmodel->data_baseboneposeinverse        = (float *)data; data += loadmodel->num_bones * sizeof(float[12]);
    loadmodel->modelsurfaces_sorted              = (int *)data; data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->surfmesh.data_element3i           = (int *)data; data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
    loadmodel->surfmesh.num_blends = 0;
    loadmodel->surfmesh.blends        = (unsigned short *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned short);
    if (loadmodel->surfmesh.num_vertices <= 65536)
    {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
    }
    loadmodel->data_poses7s                            = (short *)data; data += loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]);
    loadmodel->surfmesh.data_skeletalindex4ub  = (unsigned char *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
    loadmodel->surfmesh.data_skeletalweight4ub = (unsigned char *)data; data += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
    // Struct alignment requirements could change so we can't assume them here
    // otherwise a safe-looking commit could introduce undefined behaviour!
    loadmodel->data_surfaces = Mem_AllocType(loadmodel->mempool, msurface_t, loadmodel->num_surfaces * sizeof(msurface_t));
    loadmodel->data_textures = Mem_AllocType(loadmodel->mempool, texture_t, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
    loadmodel->skinscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numskins * sizeof(animscene_t));
    loadmodel->data_bones = Mem_AllocType(loadmodel->mempool, aliasbone_t, loadmodel->num_bones * sizeof(aliasbone_t));
    loadmodel->animscenes = Mem_AllocType(loadmodel->mempool, animscene_t, loadmodel->numframes * sizeof(animscene_t));
    loadmodel->surfmesh.data_blendweights = Mem_AllocType(loadmodel->mempool, blendweights_t, loadmodel->surfmesh.num_vertices * sizeof(blendweights_t));
 
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // create surfaces
    for (index = 0, i = 0;index < nummatts;index++)
    {
        // since psk models do not have named sections, reuse their shader name as the section name
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + index, skinfiles, matts[index].name, matts[index].name);
        loadmodel->modelsurfaces_sorted[index] = index;
        loadmodel->data_surfaces[index].texture = loadmodel->data_textures + index;
        loadmodel->data_surfaces[index].num_firstvertex = 0;
        loadmodel->data_surfaces[index].num_vertices = loadmodel->surfmesh.num_vertices;
    }
 
    // copy over the vertex locations and texcoords
    for (index = 0;index < numvtxw;index++)
    {
        loadmodel->surfmesh.data_vertex3f[index*3+0] = pnts[vtxw[index].pntsindex].origin[0];
        loadmodel->surfmesh.data_vertex3f[index*3+1] = pnts[vtxw[index].pntsindex].origin[1];
        loadmodel->surfmesh.data_vertex3f[index*3+2] = pnts[vtxw[index].pntsindex].origin[2];
        loadmodel->surfmesh.data_texcoordtexture2f[index*2+0] = vtxw[index].texcoord[0];
        loadmodel->surfmesh.data_texcoordtexture2f[index*2+1] = vtxw[index].texcoord[1];
    }
 
    // loading the faces is complicated because we need to sort them into surfaces by mattindex
    for (index = 0;index < numfaces;index++)
        loadmodel->data_surfaces[faces[index].mattindex].num_triangles++;
    for (index = 0, i = 0;index < nummatts;index++)
    {
        loadmodel->data_surfaces[index].num_firsttriangle = i;
        i += loadmodel->data_surfaces[index].num_triangles;
        loadmodel->data_surfaces[index].num_triangles = 0;
    }
    for (index = 0;index < numfaces;index++)
    {
        i = (loadmodel->data_surfaces[faces[index].mattindex].num_firsttriangle + loadmodel->data_surfaces[faces[index].mattindex].num_triangles++)*3;
        loadmodel->surfmesh.data_element3i[i+0] = faces[index].vtxwindex[0];
        loadmodel->surfmesh.data_element3i[i+1] = faces[index].vtxwindex[1];
        loadmodel->surfmesh.data_element3i[i+2] = faces[index].vtxwindex[2];
    }
 
    // copy over the bones
    for (index = 0;index < numbones;index++)
    {
        dp_strlcpy(loadmodel->data_bones[index].name, bones[index].name, sizeof(loadmodel->data_bones[index].name));
        loadmodel->data_bones[index].parent = (index || bones[index].parent > 0) ? bones[index].parent : -1;
        if (loadmodel->data_bones[index].parent >= index)
            Host_Error("%s bone[%i].parent >= %i", loadmodel->name, index, index);
    }
 
    // convert the basepose data
    if (loadmodel->num_bones)
    {
        int boneindex;
        matrix4x4_t *basebonepose;
        float *outinvmatrix = loadmodel->data_baseboneposeinverse;
        matrix4x4_t bonematrix;
        matrix4x4_t tempbonematrix;
        basebonepose = (matrix4x4_t *)Mem_Alloc(tempmempool, loadmodel->num_bones * sizeof(matrix4x4_t));
        for (boneindex = 0;boneindex < loadmodel->num_bones;boneindex++)
        {
            Matrix4x4_FromOriginQuat(&bonematrix, bones[boneindex].basepose.origin[0], bones[boneindex].basepose.origin[1], bones[boneindex].basepose.origin[2], bones[boneindex].basepose.quat[0], bones[boneindex].basepose.quat[1], bones[boneindex].basepose.quat[2], bones[boneindex].basepose.quat[3]);
            if (loadmodel->data_bones[boneindex].parent >= 0)
            {
                tempbonematrix = bonematrix;
                Matrix4x4_Concat(&bonematrix, basebonepose + loadmodel->data_bones[boneindex].parent, &tempbonematrix);
            }
            basebonepose[boneindex] = bonematrix;
            Matrix4x4_Invert_Simple(&tempbonematrix, basebonepose + boneindex);
            Matrix4x4_ToArray12FloatD3D(&tempbonematrix, outinvmatrix + 12*boneindex);
        }
        Mem_Free(basebonepose);
    }
 
    // sort the psk point weights into the vertex weight tables
    // (which only accept up to 4 bones per vertex)
    for (index = 0;index < numvtxw;index++)
    {
        int weightindex[4] = { 0, 0, 0, 0 };
        float weightinfluence[4] = { 0, 0, 0, 0 };
        int l;
        for (j = 0;j < numrawweights;j++)
        {
            if (rawweights[j].pntsindex == vtxw[index].pntsindex)
            {
                int boneindex = rawweights[j].boneindex;
                float influence = rawweights[j].weight;
                for (l = 0;l < 4;l++)
                {
                    if (weightinfluence[l] < influence)
                    {
                        // move lower influence weights out of the way first
                        int l2;
                        for (l2 = 3;l2 > l;l2--)
                        {
                            weightinfluence[l2] = weightinfluence[l2-1];
                            weightindex[l2] = weightindex[l2-1];
                        }
                        // store the new weight
                        weightinfluence[l] = influence;
                        weightindex[l] = boneindex;
                        break;
                    }
                }
            }
        }
        loadmodel->surfmesh.blends[index] = Mod_Skeletal_CompressBlend(loadmodel, weightindex, weightinfluence);
        loadmodel->surfmesh.data_skeletalindex4ub[index*4  ] = weightindex[0];
        loadmodel->surfmesh.data_skeletalindex4ub[index*4+1] = weightindex[1];
        loadmodel->surfmesh.data_skeletalindex4ub[index*4+2] = weightindex[2];
        loadmodel->surfmesh.data_skeletalindex4ub[index*4+3] = weightindex[3];
        loadmodel->surfmesh.data_skeletalweight4ub[index*4  ] = (unsigned char)(weightinfluence[0]*255.0f);
        loadmodel->surfmesh.data_skeletalweight4ub[index*4+1] = (unsigned char)(weightinfluence[1]*255.0f);
        loadmodel->surfmesh.data_skeletalweight4ub[index*4+2] = (unsigned char)(weightinfluence[2]*255.0f);
        loadmodel->surfmesh.data_skeletalweight4ub[index*4+3] = (unsigned char)(weightinfluence[3]*255.0f);
    }
    if (loadmodel->surfmesh.num_blends < loadmodel->surfmesh.num_vertices)
        loadmodel->surfmesh.data_blendweights = Mem_ReallocType(loadmodel->mempool, loadmodel->surfmesh.data_blendweights, blendweights_t, loadmodel->surfmesh.num_blends * sizeof(blendweights_t));
 
    // set up the animscenes based on the anims
    if (numanims)
    {
        for (index = 0, i = 0;index < numanims;index++)
        {
            for (j = 0;j < anims[index].numframes;j++, i++)
            {
                dpsnprintf(loadmodel->animscenes[i].name, sizeof(loadmodel->animscenes[i].name), "%s_%d", anims[index].name, j);
                loadmodel->animscenes[i].firstframe = i;
                loadmodel->animscenes[i].framecount = 1;
                loadmodel->animscenes[i].loop = true;
                loadmodel->animscenes[i].framerate = anims[index].fps;
            }
        }
        // calculate the scaling value for bone origins so they can be compressed to short
        biggestorigin = 0;
        for (index = 0;index < numanimkeys;index++)
        {
            pskanimkeys_t *k = animkeys + index;
            biggestorigin = max(biggestorigin, fabs(k->origin[0]));
            biggestorigin = max(biggestorigin, fabs(k->origin[1]));
            biggestorigin = max(biggestorigin, fabs(k->origin[2]));
        }
        loadmodel->num_posescale = biggestorigin / 32767.0f;
        if (loadmodel->num_posescale == 0) // don't divide by zero
            loadmodel->num_posescale = 1.0;
        loadmodel->num_poseinvscale = 1.0f / loadmodel->num_posescale;
    
        // load the poses from the animkeys
        for (index = 0;index < numanimkeys;index++)
        {
            pskanimkeys_t *k = animkeys + index;
            float quat[4];
            Vector4Copy(k->quat, quat);
            if (quat[3] > 0)
                Vector4Negate(quat, quat);
            Vector4Normalize2(quat, quat);
            // compress poses to the short[7] format for longterm storage
            loadmodel->data_poses7s[index*7+0] = k->origin[0] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+1] = k->origin[1] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+2] = k->origin[2] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+3] = quat[0] * 32767.0f;
            loadmodel->data_poses7s[index*7+4] = quat[1] * 32767.0f;
            loadmodel->data_poses7s[index*7+5] = quat[2] * 32767.0f;
            loadmodel->data_poses7s[index*7+6] = quat[3] * 32767.0f;
        }
    }
    else
    {
        dp_strlcpy(loadmodel->animscenes[0].name, "base", sizeof(loadmodel->animscenes[0].name));
        loadmodel->animscenes[0].firstframe = 0;
        loadmodel->animscenes[0].framecount = 1;
        loadmodel->animscenes[0].loop = true;
        loadmodel->animscenes[0].framerate = 10;
 
        // calculate the scaling value for bone origins so they can be compressed to short
        biggestorigin = 0;
        for (index = 0;index < numbones;index++)
        {
            pskboneinfo_t *p = bones + index;
            biggestorigin = max(biggestorigin, fabs(p->basepose.origin[0]));
            biggestorigin = max(biggestorigin, fabs(p->basepose.origin[1]));
            biggestorigin = max(biggestorigin, fabs(p->basepose.origin[2]));
        }
        loadmodel->num_posescale = biggestorigin / 32767.0f;
        if (loadmodel->num_posescale == 0) // don't divide by zero
            loadmodel->num_posescale = 1.0;
        loadmodel->num_poseinvscale = 1.0f / loadmodel->num_posescale;
    
        // load the basepose as a frame
        for (index = 0;index < numbones;index++)
        {
            pskboneinfo_t *p = bones + index;
            float quat[4];
            Vector4Copy(p->basepose.quat, quat);
            if (quat[3] > 0)
                Vector4Negate(quat, quat);
            Vector4Normalize2(quat, quat);
            // compress poses to the short[7] format for longterm storage
            loadmodel->data_poses7s[index*7+0] = p->basepose.origin[0] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+1] = p->basepose.origin[1] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+2] = p->basepose.origin[2] * loadmodel->num_poseinvscale;
            loadmodel->data_poses7s[index*7+3] = quat[0] * 32767.0f;
            loadmodel->data_poses7s[index*7+4] = quat[1] * 32767.0f;
            loadmodel->data_poses7s[index*7+5] = quat[2] * 32767.0f;
            loadmodel->data_poses7s[index*7+6] = quat[3] * 32767.0f;
        }
    }
 
    Mod_FreeSkinFiles(skinfiles);
    if (animfilebuffer)
        Mem_Free(animfilebuffer);
    Mod_MakeSortedSurfaces(loadmodel);
 
    // compute all the mesh information that was not loaded from the file
    // TODO: honor smoothing groups somehow?
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
    Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
    Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0);
    Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0);
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References model_t::AnimateVertices, model_t::animscenes, pskboneinfo_t::basepose, surfmesh_t::blends, pskrawweights_t::boneindex, buffer, model_t::collision_bih, model_t::CompileShadowMap, Con_DPrintf(), Con_Printf(), data, model_t::data_baseboneposeinverse, surfmesh_t::data_blendweights, model_t::data_bones, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_normal3f, model_t::data_poses7s, surfmesh_t::data_skeletalindex4ub, surfmesh_t::data_skeletalweight4ub, model_t::data_surfaces, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, developer_extra, dp_strlcat, dp_strlcpy, dpsnprintf(), model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, fabs(), animscene_t::firstframe, pskaniminfo_t::firstframe, pskaniminfo_t::fps, animscene_t::framecount, animscene_t::framerate, pskanimkeys_t::frametime, FS_LoadFile(), FS_StripExtension(), pskface_t::group, Host_Error(), i, pskchunk_t::id, index, int(), cvar_t::integer, surfmesh_t::isanimated, LittleFloat, LittleLong, LittleShort, loadmodel, animscene_t::loop, Matrix4x4_Concat(), Matrix4x4_FromOriginQuat(), Matrix4x4_Invert_Simple(), Matrix4x4_ToArray12FloatD3D(), pskface_t::mattindex, max, MAX_QPATH, Mem_Alloc, Mem_AllocType, Mem_Free, Mem_ReallocType, model_t::mempool, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildNormals(), Mod_BuildTextureVectorsFromNormals(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_Skeletal_AnimateVertices(), Mod_Skeletal_CompressBlend(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, aliasbone_t::name, animscene_t::name, model_t::name, pskaniminfo_t::name, pskboneinfo_t::name, pskmatt_t::name, NULL, surfmesh_t::num_blends, model_t::num_bones, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, model_t::num_poseinvscale, model_t::num_poses, model_t::num_posescale, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, msurface_t::num_vertices, surfmesh_t::num_vertices, pskaniminfo_t::numbones, pskboneinfo_t::numchildren, model_t::numframes, pskaniminfo_t::numframes, pskchunk_t::numrecords, model_t::numskins, pskanimkeys_t::origin, pskpnts_t::origin, pskpose_t::origin, aliasbone_t::parent, pskboneinfo_t::parent, pskaniminfo_t::playtime, pskrawweights_t::pntsindex, pskvtxw_t::pntsindex, model_t::PointSuperContents, pskanimkeys_t::quat, pskpose_t::quat, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), r_smoothnormals_areaweighting, pskchunk_t::recordsize, pskpose_t::size, model_t::skinscenes, ST_RAND, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, model_t::surfmesh, model_t::synctype, tempmempool, pskvtxw_t::texcoord, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, model_t::type, pskpose_t::unknown, Vector4Copy, Vector4Negate, Vector4Normalize2, pskchunk_t::version, version, pskface_t::vtxwindex, and pskrawweights_t::weight.

Mod_PurgeUnused()

void Mod_PurgeUnused

(

void

)

Definition at line 574 of file model_shared.c.

{
    int i;
    int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
    model_t *mod;
    for (i = 0;i < nummodels;i++)
    {
        if ((mod = (model_t*) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && !mod->used)
        {
            Mod_UnloadModel(mod);
            Mem_ExpandableArray_FreeRecord(&models, mod);
        }
    }
}

References i, int(), Mem_ExpandableArray_FreeRecord(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), mod(), Mod_UnloadModel(), and models.

Referenced by CL_SignonReply(), and SV_SpawnServer().

Mod_Q1BSP_Load()

void Mod_Q1BSP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 3903 of file model_brush.c.

{
    int i, j, k;
    sizebuf_t lumpsb[HEADER_LUMPS];
    mmodel_t *bm;
    float dist, modelyawradius, modelradius;
    msurface_t *surface;
    hullinfo_t hullinfo;
    int totalstylesurfaces, totalstyles, stylecounts[256], remapstyles[256];
    model_brush_lightstyleinfo_t styleinfo[256];
    int *datapointer;
    model_brush_lightstyleinfo_t *lsidatapointer;
    sizebuf_t sb;
 
    MSG_InitReadBuffer(&sb, (unsigned char *)buffer, (unsigned char *)bufferend - (unsigned char *)buffer);
 
    mod->type = mod_brushq1;
 
    mod->brush.skymasking = true;
    i = MSG_ReadLittleLong(&sb);
 
    if(!mod->modeldatatypestring)
        mod->modeldatatypestring = "Q1BSP";
 
// fill in hull info
    VectorClear (hullinfo.hullsizes[0][0]);
    VectorClear (hullinfo.hullsizes[0][1]);
    if (mod->brush.ishlbsp)
    {
        hullinfo.filehulls = 4;
        VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
        VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
        VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
        VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
        VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
        VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
    }
    else
    {
        hullinfo.filehulls = 4;
        VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
        VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
        VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
        VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
    }
 
// read lumps
    for (i = 0; i < HEADER_LUMPS; i++)
    {
        int offset = MSG_ReadLittleLong(&sb);
        int size = MSG_ReadLittleLong(&sb);
        if (offset < 0 || offset + size > sb.cursize)
            Host_Error("Mod_Q1BSP_Load: %s has invalid lump %i (offset %i, size %i, file size %i)\n", mod->name, i, offset, size, (int)sb.cursize);
        MSG_InitReadBuffer(&lumpsb[i], sb.data + offset, size);
    }
 
    mod->soundfromcenter = true;
    mod->TraceBox = Mod_Q1BSP_TraceBox;
    mod->TraceLine = Mod_Q1BSP_TraceLine;
    mod->TracePoint = Mod_Q1BSP_TracePoint;
    mod->PointSuperContents = Mod_Q1BSP_PointSuperContents;
    mod->TraceLineAgainstSurfaces = Mod_Q1BSP_TraceLineAgainstSurfaces;
    mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
    mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
    mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
    mod->brush.GetPVS = Mod_BSP_GetPVS;
    mod->brush.FatPVS = Mod_BSP_FatPVS;
    mod->brush.BoxTouchingPVS = Mod_BSP_BoxTouchingPVS;
    mod->brush.BoxTouchingLeafPVS = Mod_BSP_BoxTouchingLeafPVS;
    mod->brush.BoxTouchingVisibleLeafs = Mod_BSP_BoxTouchingVisibleLeafs;
    mod->brush.FindBoxClusters = Mod_BSP_FindBoxClusters;
    mod->brush.LightPoint = Mod_BSP_LightPoint;
    mod->brush.FindNonSolidLocation = Mod_BSP_FindNonSolidLocation;
    mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
    mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
    mod->brush.PointInLeaf = Mod_BSP_PointInLeaf;
    mod->Draw = R_Mod_Draw;
    mod->DrawDepth = R_Mod_DrawDepth;
    mod->DrawDebug = R_Mod_DrawDebug;
    mod->DrawPrepass = R_Mod_DrawPrepass;
    mod->GetLightInfo = R_Mod_GetLightInfo;
    mod->CompileShadowMap = R_Mod_CompileShadowMap;
    mod->DrawShadowMap = R_Mod_DrawShadowMap;
    mod->DrawLight = R_Mod_DrawLight;
 
// load into heap
 
    mod->brush.qw_md4sum = 0;
    mod->brush.qw_md4sum2 = 0;
    for (i = 0;i < HEADER_LUMPS;i++)
    {
        int temp;
        if (i == LUMP_ENTITIES)
            continue;
        temp = Com_BlockChecksum(lumpsb[i].data, lumpsb[i].cursize);
        mod->brush.qw_md4sum ^= LittleLong(temp);
        if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
            continue;
        mod->brush.qw_md4sum2 ^= LittleLong(temp);
    }
 
    Mod_Q1BSP_LoadEntities(&lumpsb[LUMP_ENTITIES]);
    Mod_Q1BSP_LoadVertexes(&lumpsb[LUMP_VERTEXES]);
    Mod_Q1BSP_LoadEdges(&lumpsb[LUMP_EDGES]);
    Mod_Q1BSP_LoadSurfedges(&lumpsb[LUMP_SURFEDGES]);
    Mod_Q1BSP_LoadTextures(&lumpsb[LUMP_TEXTURES]);
    Mod_Q1BSP_LoadLighting(&lumpsb[LUMP_LIGHTING]);
    Mod_Q1BSP_LoadPlanes(&lumpsb[LUMP_PLANES]);
    Mod_Q1BSP_LoadTexinfo(&lumpsb[LUMP_TEXINFO]);
    Mod_Q1BSP_LoadFaces(&lumpsb[LUMP_FACES]);
    Mod_Q1BSP_LoadLeaffaces(&lumpsb[LUMP_MARKSURFACES]);
    Mod_Q1BSP_LoadVisibility(&lumpsb[LUMP_VISIBILITY]);
    // load submodels before leafs because they contain the number of vis leafs
    Mod_BSP_LoadSubmodels(&lumpsb[LUMP_MODELS], &hullinfo);
    Mod_Q1BSP_LoadLeafs(&lumpsb[LUMP_LEAFS]);
    Mod_Q1BSP_LoadNodes(&lumpsb[LUMP_NODES]);
    Mod_Q1BSP_LoadClipnodes(&lumpsb[LUMP_CLIPNODES], &hullinfo);
 
    for (i = 0; i < HEADER_LUMPS; i++)
        if (lumpsb[i].readcount != lumpsb[i].cursize && i != LUMP_TEXTURES && i != LUMP_LIGHTING)
            Host_Error("Lump %i incorrectly loaded (readcount %i, size %i)\n", i, lumpsb[i].readcount, lumpsb[i].cursize);
 
    // check if the map supports transparent water rendering
    loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport();
 
    // we don't need the compressed pvs data anymore
    if (mod->brushq1.data_compressedpvs)
        Mem_Free(mod->brushq1.data_compressedpvs);
    mod->brushq1.data_compressedpvs = NULL;
    mod->brushq1.num_compressedpvs = 0;
 
    Mod_Q1BSP_MakeHull0();
    if (mod_bsp_portalize.integer && cls.state != ca_dedicated)
        Mod_BSP_MakePortals();
 
    mod->numframes = 2;     // regular and alternate animation
    mod->numskins = 1;
 
    if (loadmodel->brush.numsubmodels)
        loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
 
    // LadyHavoc: to clear the fog around the original quake submodel code, I
    // will explain:
    // first of all, some background info on the submodels:
    // model 0 is the map model (the world, named maps/e1m1.bsp for example)
    // model 1 and higher are submodels (doors and the like, named *1, *2, etc)
    // now the weird for loop itself:
    // the loop functions in an odd way, on each iteration it sets up the
    // current 'mod' model (which despite the confusing code IS the model of
    // the number i), at the end of the loop it duplicates the model to become
    // the next submodel, and loops back to set up the new submodel.
 
    // LadyHavoc: now the explanation of my sane way (which works identically):
    // set up the world model, then on each submodel copy from the world model
    // and set up the submodel with the respective model info.
    totalstylesurfaces = 0;
    totalstyles = 0;
    for (i = 0;i < mod->brush.numsubmodels;i++)
    {
        memset(stylecounts, 0, sizeof(stylecounts));
        for (k = 0;k < mod->brushq1.submodels[i].numfaces;k++)
        {
            surface = mod->data_surfaces + mod->brushq1.submodels[i].firstface + k;
            for (j = 0;j < MAXLIGHTMAPS;j++)
                stylecounts[surface->lightmapinfo->styles[j]]++;
        }
        for (k = 0;k < 255;k++)
        {
            totalstyles++;
            if (stylecounts[k])
                totalstylesurfaces += stylecounts[k];
        }
    }
    // bones_was_here: using a separate allocation for model_brush_lightstyleinfo_t
    // because on a 64-bit machine it no longer has the same alignment requirement as int.
    lsidatapointer = Mem_AllocType(mod->mempool, model_brush_lightstyleinfo_t, totalstyles * sizeof(model_brush_lightstyleinfo_t));
    datapointer = Mem_AllocType(mod->mempool, int, mod->num_surfaces * sizeof(int) + totalstylesurfaces * sizeof(int));
    mod->modelsurfaces_sorted = datapointer;datapointer += mod->num_surfaces;
    for (i = 0;i < mod->brush.numsubmodels;i++)
    {
        // LadyHavoc: this code was originally at the end of this loop, but
        // has been transformed to something more readable at the start here.
 
        if (i > 0)
        {
            char name[10];
            // duplicate the basic information
            dpsnprintf(name, sizeof(name), "*%i", i);
            mod = Mod_FindName(name, loadmodel->name);
            // copy the base model to this one
            *mod = *loadmodel;
            // rename the clone back to its proper name
            dp_strlcpy(mod->name, name, sizeof(mod->name));
            mod->brush.parentmodel = loadmodel;
            // textures and memory belong to the main model
            mod->texturepool = NULL;
            mod->mempool = NULL;
            mod->brush.GetPVS = NULL;
            mod->brush.FatPVS = NULL;
            mod->brush.BoxTouchingPVS = NULL;
            mod->brush.BoxTouchingLeafPVS = NULL;
            mod->brush.BoxTouchingVisibleLeafs = NULL;
            mod->brush.FindBoxClusters = NULL;
            mod->brush.LightPoint = NULL;
            mod->brush.AmbientSoundLevelsForPoint = NULL;
        }
 
        mod->brush.submodel = i;
 
        if (loadmodel->brush.submodels)
            loadmodel->brush.submodels[i] = mod;
 
        bm = &mod->brushq1.submodels[i];
 
        mod->brushq1.hulls[0].firstclipnode = bm->headnode[0];
        for (j=1 ; j<MAX_MAP_HULLS ; j++)
        {
            mod->brushq1.hulls[j].firstclipnode = bm->headnode[j];
            mod->brushq1.hulls[j].lastclipnode = mod->brushq1.numclipnodes - 1;
        }
 
        mod->submodelsurfaces_start = bm->firstface;
        mod->submodelsurfaces_end = bm->firstface + bm->numfaces;
 
        // set node/leaf parents for this submodel
        Mod_BSP_LoadNodes_RecursiveSetParent(mod->brush.data_nodes + mod->brushq1.hulls[0].firstclipnode, NULL);
 
        // this has to occur after hull info has been set, as it uses Mod_Q1BSP_PointSuperContents
        Mod_Q1BSP_AssignNoShadowSkySurfaces(mod);
 
        // copy the submodel bounds, then enlarge the yaw and rotated bounds according to radius
        // (previously this code measured the radius of the vertices of surfaces in the submodel, but that broke submodels that contain only CLIP brushes, which do not produce surfaces)
        VectorCopy(bm->mins, mod->normalmins);
        VectorCopy(bm->maxs, mod->normalmaxs);
        dist = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
        modelyawradius = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
        modelyawradius = dist*dist+modelyawradius*modelyawradius;
        modelradius = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
        modelradius = modelyawradius + modelradius * modelradius;
        modelyawradius = sqrt(modelyawradius);
        modelradius = sqrt(modelradius);
        mod->yawmins[0] = mod->yawmins[1] = -modelyawradius;
        mod->yawmins[2] = mod->normalmins[2];
        mod->yawmaxs[0] = mod->yawmaxs[1] =  modelyawradius;
        mod->yawmaxs[2] = mod->normalmaxs[2];
        mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
        mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] =  modelradius;
        mod->radius = modelradius;
        mod->radius2 = modelradius * modelradius;
 
        Mod_SetDrawSkyAndWater(mod);
 
        if (mod->submodelsurfaces_start < mod->submodelsurfaces_end)
        {
            // build lightstyle update chains
            // (used to rapidly mark lightmapupdateflags on many surfaces
            // when d_lightstylevalue changes)
            memset(stylecounts, 0, sizeof(stylecounts));
            for (k = mod->submodelsurfaces_start;k < mod->submodelsurfaces_end;k++)
                for (j = 0;j < MAXLIGHTMAPS;j++)
                    stylecounts[mod->data_surfaces[k].lightmapinfo->styles[j]]++;
            mod->brushq1.num_lightstyles = 0;
            for (k = 0;k < 255;k++)
            {
                if (stylecounts[k])
                {
                    styleinfo[mod->brushq1.num_lightstyles].style = k;
                    styleinfo[mod->brushq1.num_lightstyles].value = 0;
                    styleinfo[mod->brushq1.num_lightstyles].numsurfaces = 0;
                    styleinfo[mod->brushq1.num_lightstyles].surfacelist = datapointer;datapointer += stylecounts[k];
                    remapstyles[k] = mod->brushq1.num_lightstyles;
                    mod->brushq1.num_lightstyles++;
                }
            }
            for (k = mod->submodelsurfaces_start;k < mod->submodelsurfaces_end;k++)
            {
                surface = mod->data_surfaces + k;
                for (j = 0;j < MAXLIGHTMAPS;j++)
                {
                    if (surface->lightmapinfo->styles[j] != 255)
                    {
                        int r = remapstyles[surface->lightmapinfo->styles[j]];
                        styleinfo[r].surfacelist[styleinfo[r].numsurfaces++] = k;
                    }
                }
            }
            mod->brushq1.data_lightstyleinfo = lsidatapointer;lsidatapointer += mod->brushq1.num_lightstyles;
            memcpy(mod->brushq1.data_lightstyleinfo, styleinfo, mod->brushq1.num_lightstyles * sizeof(model_brush_lightstyleinfo_t));
        }
        else
        {
            // LadyHavoc: empty submodel(lacrima.bsp has such a glitch)
            Con_Printf(CON_WARN "warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
        }
        //mod->brushq1.num_visleafs = bm->visleafs;
 
        // build a Bounding Interval Hierarchy for culling triangles in light rendering
        Mod_MakeCollisionBIH(mod, true, &mod->render_bih);
 
        if (mod_q1bsp_polygoncollisions.integer)
        {
            mod->collision_bih = mod->render_bih;
            // point traces and contents checks still use the bsp tree
            mod->TraceLine = Mod_CollisionBIH_TraceLine;
            mod->TraceBox = Mod_CollisionBIH_TraceBox;
            mod->TraceBrush = Mod_CollisionBIH_TraceBrush;
            mod->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLineAgainstSurfaces;
        }
 
        // generate VBOs and other shared data before cloning submodels
        if (i == 0)
        {
            Mod_BuildVBOs();
            Mod_Q1BSP_LoadMapBrushes();
            //Mod_Q1BSP_ProcessLightList();
        }
    }
    mod = loadmodel;
 
    // make the model surface list (used by shadowing/lighting)
    Mod_MakeSortedSurfaces(loadmodel);
 
    Con_DPrintf("Stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces);
}

References model_t::brush, buffer, ca_dedicated, cls, Com_BlockChecksum(), Con_DPrintf(), Con_Printf(), CON_WARN, sizebuf_t::cursize, data, sizebuf_t::data, dp_strlcpy, dpsnprintf(), fabs(), hullinfo_t::filehulls, mmodel_t::firstface, HEADER_LUMPS, mmodel_t::headnode, Host_Error(), hullinfo_t::hullsizes, i, cvar_t::integer, msurface_t::lightmapinfo, LittleLong, loadmodel, LUMP_CLIPNODES, LUMP_EDGES, LUMP_ENTITIES, LUMP_FACES, LUMP_LEAFS, LUMP_LIGHTING, LUMP_MARKSURFACES, LUMP_MODELS, LUMP_NODES, LUMP_PLANES, LUMP_SURFEDGES, LUMP_TEXINFO, LUMP_TEXTURES, LUMP_VERTEXES, LUMP_VISIBILITY, max, MAX_MAP_HULLS, MAXLIGHTMAPS, mmodel_t::maxs, Mem_Alloc, Mem_AllocType, Mem_Free, model_t::mempool, mmodel_t::mins, mod(), mod_brushq1, Mod_BSP_BoxTouchingLeafPVS(), Mod_BSP_BoxTouchingPVS(), Mod_BSP_BoxTouchingVisibleLeafs(), Mod_BSP_FatPVS(), Mod_BSP_FindBoxClusters(), Mod_BSP_FindNonSolidLocation(), Mod_BSP_GetPVS(), Mod_BSP_LightPoint(), Mod_BSP_LoadNodes_RecursiveSetParent(), Mod_BSP_LoadSubmodels(), Mod_BSP_MakePortals(), Mod_BSP_PointInLeaf(), mod_bsp_portalize, Mod_BuildVBOs(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TraceLineAgainstSurfaces(), Mod_FindName(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_Q1BSP_AmbientSoundLevelsForPoint(), Mod_Q1BSP_AssignNoShadowSkySurfaces(), Mod_Q1BSP_CheckWaterAlphaSupport(), Mod_Q1BSP_LoadClipnodes(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadEntities(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadLeaffaces(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadPlanes(), Mod_Q1BSP_LoadSurfedges(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_LoadVertexes(), Mod_Q1BSP_LoadVisibility(), Mod_Q1BSP_MakeHull0(), Mod_Q1BSP_NativeContentsFromSuperContents(), Mod_Q1BSP_PointSuperContents(), mod_q1bsp_polygoncollisions, Mod_Q1BSP_RoundUpToHullSize(), Mod_Q1BSP_SuperContentsFromNativeContents(), Mod_Q1BSP_TraceBox(), Mod_Q1BSP_TraceLine(), Mod_Q1BSP_TraceLineAgainstSurfaces(), Mod_Q1BSP_TraceLineOfSight(), Mod_Q1BSP_TracePoint(), Mod_SetDrawSkyAndWater(), MSG_InitReadBuffer(), MSG_ReadLittleLong(), model_t::name, name, NULL, model_brush_t::num_leafs, model_brush_t::num_nodes, model_brush_t::num_portals, model_t::num_surfaces, surfmesh_t::num_triangles, surfmesh_t::num_vertices, mmodel_t::numfaces, model_brush_t::numsubmodels, model_brush_lightstyleinfo_t::numsurfaces, offset, r, R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), R_Mod_GetLightInfo(), size, sqrt(), client_static_t::state, model_brush_lightstyleinfo_t::style, msurface_lightmapinfo_t::styles, model_brush_t::submodels, model_brush_t::supportwateralpha, model_brush_lightstyleinfo_t::surfacelist, model_t::surfmesh, model_brush_lightstyleinfo_t::value, VectorClear, VectorCopy, and VectorSet.

Referenced by Mod_2PSB_Load(), Mod_BSP2_Load(), and Mod_HLBSP_Load().

Mod_Q1BSP_NativeContentsFromSuperContents()

int Mod_Q1BSP_NativeContentsFromSuperContents

(

int

supercontents

)

Definition at line 650 of file model_brush.c.

{
    if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))
        return CONTENTS_SOLID;
    if (supercontents & SUPERCONTENTS_SKY)
        return CONTENTS_SKY;
    if (supercontents & SUPERCONTENTS_LAVA)
        return CONTENTS_LAVA;
    if (supercontents & SUPERCONTENTS_SLIME)
        return CONTENTS_SLIME;
    if (supercontents & SUPERCONTENTS_WATER)
        return CONTENTS_WATER;
    return CONTENTS_EMPTY;
}

References CONTENTS_EMPTY, CONTENTS_LAVA, CONTENTS_SKY, CONTENTS_SLIME, CONTENTS_SOLID, CONTENTS_WATER, SUPERCONTENTS_BODY, SUPERCONTENTS_LAVA, SUPERCONTENTS_SKY, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, and SUPERCONTENTS_WATER.

Referenced by Mod_Q1BSP_Load(), SV_CheckWater(), SV_CheckWaterTransition(), VM_CL_pointcontents(), and VM_SV_pointcontents().

Mod_Q1BSP_SuperContentsFromNativeContents()

int Mod_Q1BSP_SuperContentsFromNativeContents

(

int

nativecontents

)

Definition at line 630 of file model_brush.c.

{
    switch(nativecontents)
    {
        case CONTENTS_EMPTY:
            return 0;
        case CONTENTS_SOLID:
            return SUPERCONTENTS_SOLID | SUPERCONTENTS_OPAQUE;
        case CONTENTS_WATER:
            return SUPERCONTENTS_WATER;
        case CONTENTS_SLIME:
            return SUPERCONTENTS_SLIME;
        case CONTENTS_LAVA:
            return SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
        case CONTENTS_SKY:
            return SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP | SUPERCONTENTS_OPAQUE; // to match behaviour of Q3 maps, let sky count as opaque
    }
    return 0;
}

References CONTENTS_EMPTY, CONTENTS_LAVA, CONTENTS_SKY, CONTENTS_SLIME, CONTENTS_SOLID, CONTENTS_WATER, SUPERCONTENTS_LAVA, SUPERCONTENTS_NODROP, SUPERCONTENTS_OPAQUE, SUPERCONTENTS_SKY, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, and SUPERCONTENTS_WATER.

Referenced by Mod_Q1BSP_Load(), Mod_Q1BSP_PointSuperContents(), Mod_Q1BSP_RecursiveHullCheck(), Mod_Q1BSP_RecursiveHullCheckPoint(), and Mod_Q1BSP_TraceLineAgainstSurfacesRecursiveBSPNode().

Mod_Q2BSP_NativeContentsFromSuperContents()

int Mod_Q2BSP_NativeContentsFromSuperContents

(

int

supercontents

)

Definition at line 4252 of file model_brush.c.

{
    int nativecontents = 0;
    if (supercontents & SUPERCONTENTS_SOLID)
        nativecontents |= CONTENTSQ2_SOLID;
    if (supercontents & SUPERCONTENTS_WATER)
        nativecontents |= CONTENTSQ2_WATER;
    if (supercontents & SUPERCONTENTS_SLIME)
        nativecontents |= CONTENTSQ2_SLIME;
    if (supercontents & SUPERCONTENTS_LAVA)
        nativecontents |= CONTENTSQ2_LAVA;
    if (supercontents & SUPERCONTENTS_BODY)
        nativecontents |= CONTENTSQ2_MONSTER;
    if (supercontents & SUPERCONTENTS_CORPSE)
        nativecontents |= CONTENTSQ2_DEADMONSTER;
    if (supercontents & SUPERCONTENTS_PLAYERCLIP)
        nativecontents |= CONTENTSQ2_PLAYERCLIP;
    if (supercontents & SUPERCONTENTS_MONSTERCLIP)
        nativecontents |= CONTENTSQ2_MONSTERCLIP;
    if (!(supercontents & SUPERCONTENTS_OPAQUE))
        nativecontents |= CONTENTSQ2_TRANSLUCENT;
    return nativecontents;
}

References CONTENTSQ2_DEADMONSTER, CONTENTSQ2_LAVA, CONTENTSQ2_MONSTER, CONTENTSQ2_MONSTERCLIP, CONTENTSQ2_PLAYERCLIP, CONTENTSQ2_SLIME, CONTENTSQ2_SOLID, CONTENTSQ2_TRANSLUCENT, CONTENTSQ2_WATER, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, SUPERCONTENTS_LAVA, SUPERCONTENTS_MONSTERCLIP, SUPERCONTENTS_OPAQUE, SUPERCONTENTS_PLAYERCLIP, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, and SUPERCONTENTS_WATER.

Referenced by Mod_Q2BSP_Load().

Mod_Q2BSP_SuperContentsFromNativeContents()

int Mod_Q2BSP_SuperContentsFromNativeContents

(

int

nativecontents

)

Definition at line 4228 of file model_brush.c.

{
    int supercontents = 0;
    if (nativecontents & CONTENTSQ2_SOLID)
        supercontents |= SUPERCONTENTS_SOLID;
    if (nativecontents & CONTENTSQ2_WATER)
        supercontents |= SUPERCONTENTS_WATER;
    if (nativecontents & CONTENTSQ2_SLIME)
        supercontents |= SUPERCONTENTS_SLIME;
    if (nativecontents & CONTENTSQ2_LAVA)
        supercontents |= SUPERCONTENTS_LAVA;
    if (nativecontents & CONTENTSQ2_MONSTER)
        supercontents |= SUPERCONTENTS_BODY;
    if (nativecontents & CONTENTSQ2_DEADMONSTER)
        supercontents |= SUPERCONTENTS_CORPSE;
    if (nativecontents & CONTENTSQ2_PLAYERCLIP)
        supercontents |= SUPERCONTENTS_PLAYERCLIP;
    if (nativecontents & CONTENTSQ2_MONSTERCLIP)
        supercontents |= SUPERCONTENTS_MONSTERCLIP;
    if (!(nativecontents & CONTENTSQ2_TRANSLUCENT))
        supercontents |= SUPERCONTENTS_OPAQUE;
    return supercontents;
}

References CONTENTSQ2_DEADMONSTER, CONTENTSQ2_LAVA, CONTENTSQ2_MONSTER, CONTENTSQ2_MONSTERCLIP, CONTENTSQ2_PLAYERCLIP, CONTENTSQ2_SLIME, CONTENTSQ2_SOLID, CONTENTSQ2_TRANSLUCENT, CONTENTSQ2_WATER, SUPERCONTENTS_BODY, SUPERCONTENTS_CORPSE, SUPERCONTENTS_LAVA, SUPERCONTENTS_MONSTERCLIP, SUPERCONTENTS_OPAQUE, SUPERCONTENTS_PLAYERCLIP, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, and SUPERCONTENTS_WATER.

Referenced by Mod_LoadTextureFromQ3Shader(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), and Mod_Q2BSP_LoadTexinfo().

Mod_Reload()

void Mod_Reload

(

void

)

Definition at line 661 of file model_shared.c.

{
    int i, count;
    int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
    model_t *mod;
 
    SCR_PushLoadingScreen("Reloading models", 1.0);
    count = 0;
    for (i = 0;i < nummodels;i++)
        if ((mod = (model_t *) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && mod->name[0] != '*' && mod->used)
            ++count;
    for (i = 0;i < nummodels;i++)
        if ((mod = (model_t *) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0] && mod->name[0] != '*' && mod->used)
        {
            SCR_PushLoadingScreen(mod->name, 1.0 / count);
            Mod_LoadModel(mod, true, true);
            SCR_PopLoadingScreen(false);
        }
    SCR_PopLoadingScreen(false);
}

References count, i, int(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), mod(), Mod_LoadModel(), models, SCR_PopLoadingScreen(), and SCR_PushLoadingScreen().

Mod_RemoveDegenerateTriangles()

int Mod_RemoveDegenerateTriangles	(	int	numtriangles,
		const int *	inelement3i,
		int *	outelement3i,
		const float *	vertex3f )

Definition at line 2841 of file model_shared.c.

{
    int i, outtriangles;
    float edgedir1[3], edgedir2[3], temp[3];
    // a degenerate triangle is one with no width (thickness, surface area)
    // these are characterized by having all 3 points colinear (along a line)
    // or having two points identical
    // the simplest check is to calculate the triangle's area
    for (i = 0, outtriangles = 0;i < numtriangles;i++, inelement3i += 3)
    {
        // calculate first edge
        VectorSubtract(vertex3f + inelement3i[1] * 3, vertex3f + inelement3i[0] * 3, edgedir1);
        VectorSubtract(vertex3f + inelement3i[2] * 3, vertex3f + inelement3i[0] * 3, edgedir2);
        CrossProduct(edgedir1, edgedir2, temp);
        if (VectorLength2(temp) < 0.001f)
            continue; // degenerate triangle (no area)
        // valid triangle (has area)
        VectorCopy(inelement3i, outelement3i);
        outelement3i += 3;
        outtriangles++;
    }
    return outtriangles;
}

References CrossProduct, i, VectorCopy, VectorLength2, and VectorSubtract.

Referenced by Mod_Q3BSP_LoadFaces().

Mod_RemoveStaleWorldModels()

void Mod_RemoveStaleWorldModels

(

model_t *

skip

)

Mod_SetDrawSkyAndWater()

void Mod_SetDrawSkyAndWater

(

model_t *

mod

)

Sets the mod->DrawSky and mod->DrawAddWaterPlanes pointers conditionally based on whether surfaces in this submodel use these features called specifically by brush model loaders when generating submodels automatically called after model loader returns.

Definition at line 2887 of file model_shared.c.

{
    int j;
    uint64_t basematerialflags = 0;
    // by default assume there is no sky or water used in this model
    mod->DrawSky = NULL;
    mod->DrawAddWaterPlanes = NULL;
    // combine all basematerialflags observed in the submodelsurfaces range, then check for special flags
    for (j = mod->submodelsurfaces_start; j < mod->submodelsurfaces_end; j++)
        if (mod->data_surfaces[j].texture)
            basematerialflags |= mod->data_surfaces[j].texture->basematerialflags;
    if (basematerialflags & MATERIALFLAG_SKY)
        mod->DrawSky = R_Mod_DrawSky;
    if (basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA))
        mod->DrawAddWaterPlanes = R_Mod_DrawAddWaterPlanes;
}

References MATERIALFLAG_CAMERA, MATERIALFLAG_REFLECTION, MATERIALFLAG_REFRACTION, MATERIALFLAG_SKY, MATERIALFLAG_WATERSHADER, mod(), NULL, R_Mod_DrawAddWaterPlanes(), and R_Mod_DrawSky().

Referenced by Mod_LoadModel(), Mod_OBJ_Load(), Mod_Q1BSP_Load(), Mod_Q2BSP_Load(), and Mod_Q3BSP_Load().

Mod_ShadowMesh_AddMesh()

void Mod_ShadowMesh_AddMesh	(	shadowmesh_t *	mesh,
		const float *	vertex3f,
		int	numtris,
		const int *	element3i )

Definition at line 1041 of file model_shared.c.

{
    int i;
 
    for (i = 0;i < numtris;i++)
    {
        if ((mesh->numtriangles * 3 + 2) * sizeof(int) + 1 >= Mem_Size(mesh->element3i))
        {
            // FIXME: we didn't allocate enough space for all the tris, see R_Mod_CompileShadowMap
            Con_Print(CON_WARN "Mod_ShadowMesh_AddMesh: insufficient memory allocated!\n");
            return;
        }
        mesh->element3i[mesh->numtriangles * 3 + 0] = Mod_ShadowMesh_AddVertex(mesh, vertex3f + 3 * element3i[i * 3 + 0]);
        mesh->element3i[mesh->numtriangles * 3 + 1] = Mod_ShadowMesh_AddVertex(mesh, vertex3f + 3 * element3i[i * 3 + 1]);
        mesh->element3i[mesh->numtriangles * 3 + 2] = Mod_ShadowMesh_AddVertex(mesh, vertex3f + 3 * element3i[i * 3 + 2]);
        mesh->numtriangles++;
    }
 
    // the triangle calculation can take a while, so let's do a keepalive here
    CL_KeepaliveMessage(false);
}

References CL_KeepaliveMessage(), Con_Print(), CON_WARN, shadowmesh_t::element3i, i, Mem_Size(), Mod_ShadowMesh_AddVertex(), and shadowmesh_t::numtriangles.

Referenced by Mod_CreateCollisionMesh(), and R_Shadow_ShadowMapFromList().

Mod_ShadowMesh_AddVertex()

int Mod_ShadowMesh_AddVertex	(	shadowmesh_t *	mesh,
		const float *	vertex3f )

Definition at line 1019 of file model_shared.c.

{
    int hashindex, vnum;
    shadowmeshvertexhash_t *hash;
    // this uses prime numbers intentionally
    hashindex = (unsigned int) (vertex3f[0] * 2003 + vertex3f[1] * 4001 + vertex3f[2] * 7919) % SHADOWMESHVERTEXHASH;
    for (hash = mesh->vertexhashtable[hashindex];hash;hash = hash->next)
    {
        vnum = (hash - mesh->vertexhashentries);
        if (mesh->vertex3f[vnum * 3 + 0] == vertex3f[0] && mesh->vertex3f[vnum * 3 + 1] == vertex3f[1] && mesh->vertex3f[vnum * 3 + 2] == vertex3f[2])
            return hash - mesh->vertexhashentries;
    }
    vnum = mesh->numverts++;
    hash = mesh->vertexhashentries + vnum;
    hash->next = mesh->vertexhashtable[hashindex];
    mesh->vertexhashtable[hashindex] = hash;
    mesh->vertex3f[vnum * 3 + 0] = vertex3f[0];
    mesh->vertex3f[vnum * 3 + 1] = vertex3f[1];
    mesh->vertex3f[vnum * 3 + 2] = vertex3f[2];
    return vnum;
}

References int(), shadowmeshvertexhash_t::next, shadowmesh_t::numverts, SHADOWMESHVERTEXHASH, shadowmesh_t::vertex3f, shadowmesh_t::vertexhashentries, and shadowmesh_t::vertexhashtable.

Referenced by Mod_ShadowMesh_AddMesh().

Mod_ShadowMesh_Alloc()

shadowmesh_t * Mod_ShadowMesh_Alloc	(	struct mempool_s *	mempool,
		int	maxverts,
		int	maxtriangles )

Mod_ShadowMesh_Begin()

shadowmesh_t * Mod_ShadowMesh_Begin	(	struct mempool_s *	mempool,
		int	maxverts,
		int	maxtriangles )

Mod_ShadowMesh_CalcBBox()

void Mod_ShadowMesh_CalcBBox	(	shadowmesh_t *	firstmesh,
		vec3_t	mins,
		vec3_t	maxs,
		vec3_t	center,
		float *	radius )

Definition at line 1136 of file model_shared.c.

{
    int i;
    vec3_t nmins, nmaxs, ncenter, temp;
    float nradius2, dist2, *v;
    VectorClear(nmins);
    VectorClear(nmaxs);
    // calculate bbox
    VectorCopy(mesh->vertex3f, nmins);
    VectorCopy(mesh->vertex3f, nmaxs);
    for (i = 0, v = mesh->vertex3f;i < mesh->numverts;i++, v += 3)
    {
        if (nmins[0] > v[0]) { nmins[0] = v[0]; } if (nmaxs[0] < v[0]) { nmaxs[0] = v[0]; }
        if (nmins[1] > v[1]) { nmins[1] = v[1]; } if (nmaxs[1] < v[1]) { nmaxs[1] = v[1]; }
        if (nmins[2] > v[2]) { nmins[2] = v[2]; } if (nmaxs[2] < v[2]) { nmaxs[2] = v[2]; }
    }
    // calculate center and radius
    ncenter[0] = (nmins[0] + nmaxs[0]) * 0.5f;
    ncenter[1] = (nmins[1] + nmaxs[1]) * 0.5f;
    ncenter[2] = (nmins[2] + nmaxs[2]) * 0.5f;
    nradius2 = 0;
    for (i = 0, v = mesh->vertex3f;i < mesh->numverts;i++, v += 3)
    {
        VectorSubtract(v, ncenter, temp);
        dist2 = DotProduct(temp, temp);
        if (nradius2 < dist2)
            nradius2 = dist2;
    }
    // return data
    if (mins)
        VectorCopy(nmins, mins);
    if (maxs)
        VectorCopy(nmaxs, maxs);
    if (center)
        VectorCopy(ncenter, center);
    if (radius)
        *radius = sqrt(nradius2);
}

References DotProduct, i, maxs, mins, sqrt(), v, VectorClear, VectorCopy, VectorSubtract, and shadowmesh_t::vertex3f.

Mod_ShadowMesh_Finish()

shadowmesh_t * Mod_ShadowMesh_Finish	(	shadowmesh_t *	firstmesh,
		qbool	createvbo )

Definition at line 1099 of file model_shared.c.

{
    if (mesh->numverts >= 3 && mesh->numtriangles >= 1)
    {
        if (mesh->vertexhashentries)
            Mem_Free(mesh->vertexhashentries);
        mesh->vertexhashentries = NULL;
        if (mesh->vertexhashtable)
            Mem_Free(mesh->vertexhashtable);
        mesh->vertexhashtable = NULL;
        if (mesh->maxverts > mesh->numverts)
        {
            mesh->vertex3f = (float *)Mem_Realloc(mesh->mempool, mesh->vertex3f, mesh->numverts * sizeof(float[3]));
            mesh->maxverts = mesh->numverts;
        }
        if (mesh->maxtriangles > mesh->numtriangles)
        {
            mesh->element3i = (int *)Mem_Realloc(mesh->mempool, mesh->element3i, mesh->numtriangles * sizeof(int[3]));
            mesh->maxtriangles = mesh->numtriangles;
        }
        if (mesh->numverts <= 65536)
        {
            int i;
            mesh->element3s = (unsigned short *)Mem_Alloc(mesh->mempool, mesh->numtriangles * sizeof(unsigned short[3]));
            for (i = 0;i < mesh->numtriangles*3;i++)
                mesh->element3s[i] = mesh->element3i[i];
        }
        if (createvbo)
            Mod_ShadowMesh_CreateVBOs(mesh);
    }
 
    // this can take a while, so let's do a keepalive here
    CL_KeepaliveMessage(false);
 
    return mesh;
}

References CL_KeepaliveMessage(), shadowmesh_t::element3i, shadowmesh_t::element3s, i, shadowmesh_t::maxtriangles, shadowmesh_t::maxverts, Mem_Alloc, Mem_Free, Mem_Realloc, shadowmesh_t::mempool, Mod_ShadowMesh_CreateVBOs(), NULL, shadowmesh_t::numtriangles, shadowmesh_t::numverts, shadowmesh_t::vertex3f, shadowmesh_t::vertexhashentries, and shadowmesh_t::vertexhashtable.

Referenced by Mod_CreateCollisionMesh(), and R_Mod_CompileShadowMap().

Mod_ShadowMesh_Free()

void Mod_ShadowMesh_Free

(

shadowmesh_t *

mesh

)

Definition at line 1175 of file model_shared.c.

{
    if (mesh->element3i_indexbuffer)
        R_Mesh_DestroyMeshBuffer(mesh->element3i_indexbuffer);
    if (mesh->element3s_indexbuffer)
        R_Mesh_DestroyMeshBuffer(mesh->element3s_indexbuffer);
    if (mesh->vbo_vertexbuffer)
        R_Mesh_DestroyMeshBuffer(mesh->vbo_vertexbuffer);
    if (mesh->vertex3f)
        Mem_Free(mesh->vertex3f);
    if (mesh->element3i)
        Mem_Free(mesh->element3i);
    if (mesh->element3s)
        Mem_Free(mesh->element3s);
    if (mesh->vertexhashentries)
        Mem_Free(mesh->vertexhashentries);
    if (mesh->vertexhashtable)
        Mem_Free(mesh->vertexhashtable);
    Mem_Free(mesh);
}

References shadowmesh_t::element3i, shadowmesh_t::element3i_indexbuffer, shadowmesh_t::element3s, shadowmesh_t::element3s_indexbuffer, Mem_Free, R_Mesh_DestroyMeshBuffer(), shadowmesh_t::vbo_vertexbuffer, shadowmesh_t::vertex3f, shadowmesh_t::vertexhashentries, and shadowmesh_t::vertexhashtable.

Referenced by R_RTLight_Uncompile().

Mod_Skeletal_FreeBuffers()

void Mod_Skeletal_FreeBuffers

(

void

)

Definition at line 46 of file model_alias.c.

{
    if(Mod_Skeletal_AnimateVertices_bonepose)
        Mem_Free(Mod_Skeletal_AnimateVertices_bonepose);
    Mod_Skeletal_AnimateVertices_maxbonepose = 0;
    Mod_Skeletal_AnimateVertices_bonepose = NULL;
}

References Mem_Free, Mod_Skeletal_AnimateVertices_bonepose, Mod_Skeletal_AnimateVertices_maxbonepose, and NULL.

Referenced by mod_shutdown().

Mod_SnapVertices()

void Mod_SnapVertices	(	int	numcomponents,
		int	numvertices,
		float *	vertices,
		float	snap )

Definition at line 2833 of file model_shared.c.

{
    int i;
    double isnap = 1.0 / snap;
    for (i = 0;i < numvertices*numcomponents;i++)
        vertices[i] = floor(vertices[i]*isnap)*snap;
}

References floor(), and i.

Referenced by Mod_Q3BSP_LoadFaces().

Mod_SpriteInit()

void Mod_SpriteInit

(

void

)

Definition at line 45 of file model_sprite.c.

{
    Cvar_RegisterVariable(&r_mipsprites);
    Cvar_RegisterVariable(&r_labelsprites_scale);
    Cvar_RegisterVariable(&r_labelsprites_roundtopixels);
    Cvar_RegisterVariable(&r_overheadsprites_perspective);
    Cvar_RegisterVariable(&r_overheadsprites_pushback);
    Cvar_RegisterVariable(&r_overheadsprites_scalex);
    Cvar_RegisterVariable(&r_overheadsprites_scaley);
    Cvar_RegisterVariable(&r_track_sprites);
    Cvar_RegisterVariable(&r_track_sprites_flags);
    Cvar_RegisterVariable(&r_track_sprites_scalew);
    Cvar_RegisterVariable(&r_track_sprites_scaleh);
}

References Cvar_RegisterVariable(), r_labelsprites_roundtopixels, r_labelsprites_scale, r_mipsprites, r_overheadsprites_perspective, r_overheadsprites_pushback, r_overheadsprites_scalex, r_overheadsprites_scaley, r_track_sprites, r_track_sprites_flags, r_track_sprites_scaleh, and r_track_sprites_scalew.

Referenced by Mod_Init().

Mod_UnloadCustomMaterial()

void Mod_UnloadCustomMaterial	(	texture_t *	texture,
		qbool	purgeskins )

Removes all shaderpasses from material, and optionally deletes the textures in the skinframes.

Definition at line 2685 of file model_shared.c.

{
    long unsigned int i, j;
    for (i = 0; i < sizeof(texture->shaderpasses) / sizeof(texture->shaderpasses[0]); i++)
    {
        if (texture->shaderpasses[i])
        {
            if (purgeskins)
                for (j = 0; j < sizeof(texture->shaderpasses[i]->skinframes) / sizeof(skinframe_t *);j++)
                    if (texture->shaderpasses[i]->skinframes[j] && texture->shaderpasses[i]->skinframes[j]->base)
                        R_SkinFrame_PurgeSkinFrame(texture->shaderpasses[i]->skinframes[j]);
            Mem_Free(texture->shaderpasses[i]);
            texture->shaderpasses[i] = NULL;
        }
    }
    texture->materialshaderpass = NULL;
    texture->currentskinframe = NULL;
    texture->backgroundcurrentskinframe = NULL;
}

References i, Mem_Free, NULL, R_SkinFrame_PurgeSkinFrame(), and texture.

Mod_UnloadModel()

void Mod_UnloadModel

(

model_t *

mod

)

Definition at line 211 of file model_shared.c.

{
    char name[MAX_QPATH];
    qbool used;
    model_t *parentmodel;
 
    if (developer_loading.integer)
        Con_Printf("unloading model %s\n", mod->name);
 
    dp_strlcpy(name, mod->name, sizeof(name));
    parentmodel = mod->brush.parentmodel;
    used = mod->used;
    if (mod->mempool)
    {
        if (mod->surfmesh.data_element3i_indexbuffer && !mod->surfmesh.data_element3i_indexbuffer->isdynamic)
            R_Mesh_DestroyMeshBuffer(mod->surfmesh.data_element3i_indexbuffer);
        mod->surfmesh.data_element3i_indexbuffer = NULL;
        if (mod->surfmesh.data_element3s_indexbuffer && !mod->surfmesh.data_element3s_indexbuffer->isdynamic)
            R_Mesh_DestroyMeshBuffer(mod->surfmesh.data_element3s_indexbuffer);
        mod->surfmesh.data_element3s_indexbuffer = NULL;
        if (mod->surfmesh.data_vertex3f_vertexbuffer && !mod->surfmesh.data_vertex3f_vertexbuffer->isdynamic)
            R_Mesh_DestroyMeshBuffer(mod->surfmesh.data_vertex3f_vertexbuffer);
        mod->surfmesh.data_vertex3f_vertexbuffer = NULL;
        mod->surfmesh.data_svector3f_vertexbuffer = NULL;
        mod->surfmesh.data_tvector3f_vertexbuffer = NULL;
        mod->surfmesh.data_normal3f_vertexbuffer = NULL;
        mod->surfmesh.data_texcoordtexture2f_vertexbuffer = NULL;
        mod->surfmesh.data_texcoordlightmap2f_vertexbuffer = NULL;
        mod->surfmesh.data_lightmapcolor4f_vertexbuffer = NULL;
        mod->surfmesh.data_skeletalindex4ub_vertexbuffer = NULL;
        mod->surfmesh.data_skeletalweight4ub_vertexbuffer = NULL;
    }
    // free textures/memory attached to the model
    R_FreeTexturePool(&mod->texturepool);
    Mem_FreePool(&mod->mempool);
    // clear the struct to make it available
    memset(mod, 0, sizeof(model_t));
    // restore the fields we want to preserve
    dp_strlcpy(mod->name, name, sizeof(mod->name));
    mod->brush.parentmodel = parentmodel;
    mod->used = used;
    mod->loaded = false;
}

References Con_Printf(), developer_loading, dp_strlcpy, cvar_t::integer, MAX_QPATH, Mem_FreePool, mod(), name, NULL, R_FreeTexturePool(), and R_Mesh_DestroyMeshBuffer().

Referenced by Mod_LoadModel(), Mod_Mesh_Destroy(), Mod_PurgeUnused(), and mod_shutdown().

Mod_ValidateElements()

qbool Mod_ValidateElements	(	int *	element3i,
		unsigned short *	element3s,
		int	numtriangles,
		int	firstvertex,
		int	numvertices,
		const char *	filename,
		int	fileline )

Definition at line 738 of file model_shared.c.

{
    int first = firstvertex, last = first + numvertices - 1, numelements = numtriangles * 3;
    int i;
    int invalidintcount = 0, invalidintexample = 0;
    int invalidshortcount = 0, invalidshortexample = 0;
    int invalidmismatchcount = 0, invalidmismatchexample = 0;
    if (element3i)
    {
        for (i = 0; i < numelements; i++)
        {
            if (element3i[i] < first || element3i[i] > last)
            {
                invalidintcount++;
                invalidintexample = i;
            }
        }
    }
    if (element3s)
    {
        for (i = 0; i < numelements; i++)
        {
            if (element3s[i] < first || element3s[i] > last)
            {
                invalidintcount++;
                invalidintexample = i;
            }
        }
    }
    if (element3i && element3s)
    {
        for (i = 0; i < numelements; i++)
        {
            if (element3s[i] != element3i[i])
            {
                invalidmismatchcount++;
                invalidmismatchexample = i;
            }
        }
    }
    if (invalidintcount || invalidshortcount || invalidmismatchcount)
    {
        Con_Printf("Mod_ValidateElements(%i, %i, %i, %p, %p) called at %s:%d", numelements, first, last, (void *)element3i, (void *)element3s, filename, fileline);
        Con_Printf(", %i elements are invalid in element3i (example: element3i[%i] == %i)", invalidintcount, invalidintexample, element3i ? element3i[invalidintexample] : 0);
        Con_Printf(", %i elements are invalid in element3s (example: element3s[%i] == %i)", invalidshortcount, invalidshortexample, element3s ? element3s[invalidshortexample] : 0);
        Con_Printf(", %i elements mismatch between element3i and element3s (example: element3s[%i] is %i and element3i[%i] is %i)", invalidmismatchcount, invalidmismatchexample, element3s ? element3s[invalidmismatchexample] : 0, invalidmismatchexample, element3i ? element3i[invalidmismatchexample] : 0);
        Con_Print(".  Please debug the engine code - these elements have been modified to not crash, but nothing more.\n");
 
        // edit the elements to make them safer, as the driver will crash otherwise
        if (element3i)
            for (i = 0; i < numelements; i++)
                if (element3i[i] < first || element3i[i] > last)
                    element3i[i] = first;
        if (element3s)
            for (i = 0; i < numelements; i++)
                if (element3s[i] < first || element3s[i] > last)
                    element3s[i] = first;
        if (element3i && element3s)
            for (i = 0; i < numelements; i++)
                if (element3s[i] != element3i[i])
                    element3s[i] = element3i[i];
 
        return false;
    }
    return true;
}

References Con_Print(), Con_Printf(), first, and i.

Referenced by Mod_DARKPLACESMODEL_Load(), Mod_IDP0_Load(), Mod_IDP3_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_ShadowMesh_CreateVBOs(), and Mod_ZYMOTICMODEL_Load().

Mod_VBSP_Load()

void Mod_VBSP_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 8312 of file model_brush.c.

{
    static cvar_t *testing = NULL; // TEMPORARY
    int i;
    sizebuf_t sb;
    sizebuf_t lumpsb[HL2HEADER_LUMPS];
 
    if(!testing || !testing->integer)
    {
        if(!testing)
            testing = Cvar_Get(&cvars_all, "mod_bsp_vbsptest", "0", CF_CLIENT | CF_SERVER, "uhhh");
        Host_Error("Mod_VBSP_Load: not yet fully implemented. Change the now-generated \"mod_bsp_vbsptest\" to 1 if you wish to test this");
    }
    else
    {
 
        MSG_InitReadBuffer(&sb, (unsigned char *)buffer, (unsigned char *)bufferend - (unsigned char *)buffer);
 
        mod->type = mod_brushhl2;
 
        MSG_ReadLittleLong(&sb);
        MSG_ReadLittleLong(&sb); // TODO version check
 
        mod->modeldatatypestring = "VBSP";
 
        // read lumps
        for (i = 0; i < HL2HEADER_LUMPS; i++)
        {
            int offset = MSG_ReadLittleLong(&sb);
            int size = MSG_ReadLittleLong(&sb);
            MSG_ReadLittleLong(&sb); // TODO support version
            MSG_ReadLittleLong(&sb); // TODO support ident
            if (offset < 0 || offset + size > sb.cursize)
                Host_Error("Mod_VBSP_Load: %s has invalid lump %i (offset %i, size %i, file size %i)\n", mod->name, i, offset, size, (int)sb.cursize);
            MSG_InitReadBuffer(&lumpsb[i], sb.data + offset, size);
        }
 
        MSG_ReadLittleLong(&sb); // TODO support revision field
 
        mod->soundfromcenter = true;
        mod->TraceBox = Mod_CollisionBIH_TraceBox;
        mod->TraceBrush = Mod_CollisionBIH_TraceBrush;
        mod->TraceLine = Mod_CollisionBIH_TraceLine;
        mod->TracePoint = Mod_CollisionBIH_TracePoint;
        mod->PointSuperContents = Mod_CollisionBIH_PointSuperContents;
        mod->TraceLineAgainstSurfaces = Mod_CollisionBIH_TraceLine;
        mod->brush.TraceLineOfSight = Mod_Q3BSP_TraceLineOfSight; // probably not correct
        mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents; // probably not correct
        mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents; // probably not correct
        mod->brush.GetPVS = Mod_BSP_GetPVS;
        mod->brush.FatPVS = Mod_BSP_FatPVS;
        mod->brush.BoxTouchingPVS = Mod_BSP_BoxTouchingPVS;
        mod->brush.BoxTouchingLeafPVS = Mod_BSP_BoxTouchingLeafPVS;
        mod->brush.BoxTouchingVisibleLeafs = Mod_BSP_BoxTouchingVisibleLeafs;
        mod->brush.FindBoxClusters = Mod_BSP_FindBoxClusters;
        mod->brush.LightPoint = Mod_Q3BSP_LightPoint; // probably not correct
        mod->brush.FindNonSolidLocation = Mod_BSP_FindNonSolidLocation;
        mod->brush.AmbientSoundLevelsForPoint = NULL;
        mod->brush.RoundUpToHullSize = NULL;
        mod->brush.PointInLeaf = Mod_BSP_PointInLeaf;
        mod->Draw = R_Mod_Draw;
        mod->DrawDepth = R_Mod_DrawDepth;
        mod->DrawDebug = R_Mod_DrawDebug;
        mod->DrawPrepass = R_Mod_DrawPrepass;
        mod->GetLightInfo = R_Mod_GetLightInfo;
        mod->CompileShadowMap = R_Mod_CompileShadowMap;
        mod->DrawShadowMap = R_Mod_DrawShadowMap;
        mod->DrawLight = R_Mod_DrawLight;
 
        // allocate a texture pool if we need it
        if (mod->texturepool == NULL)
            mod->texturepool = R_AllocTexturePool();
 
        Mod_VBSP_LoadEntities(&lumpsb[HL2LUMP_ENTITIES]);
        Mod_VBSP_LoadVertexes(&lumpsb[HL2LUMP_VERTEXES]);
        Mod_VBSP_LoadEdges(&lumpsb[HL2LUMP_EDGES]);
        Mod_VBSP_LoadSurfedges(&lumpsb[HL2LUMP_SURFEDGES]);
        Mod_VBSP_LoadTextures(&lumpsb[HL2LUMP_TEXDATA/*?*/]);
        //Mod_VBSP_LoadLighting(&lumpsb[HL2LUMP_LIGHTING]);
        Mod_VBSP_LoadPlanes(&lumpsb[HL2LUMP_PLANES]);
        Mod_VBSP_LoadTexinfo(&lumpsb[HL2LUMP_TEXINFO]);
 
        // AHHHHHHH
        Mod_VBSP_LoadFaces(&lumpsb[HL2LUMP_FACES]);
    }
}

References buffer, CF_CLIENT, CF_SERVER, sizebuf_t::cursize, Cvar_Get(), cvars_all, sizebuf_t::data, HL2HEADER_LUMPS, HL2LUMP_EDGES, HL2LUMP_ENTITIES, HL2LUMP_FACES, HL2LUMP_PLANES, HL2LUMP_SURFEDGES, HL2LUMP_TEXDATA, HL2LUMP_TEXINFO, HL2LUMP_VERTEXES, Host_Error(), i, cvar_t::integer, mod(), mod_brushhl2, Mod_BSP_BoxTouchingLeafPVS(), Mod_BSP_BoxTouchingPVS(), Mod_BSP_BoxTouchingVisibleLeafs(), Mod_BSP_FatPVS(), Mod_BSP_FindBoxClusters(), Mod_BSP_FindNonSolidLocation(), Mod_BSP_GetPVS(), Mod_BSP_PointInLeaf(), Mod_CollisionBIH_PointSuperContents(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint(), Mod_Q3BSP_LightPoint(), Mod_Q3BSP_NativeContentsFromSuperContents(), Mod_Q3BSP_SuperContentsFromNativeContents(), Mod_Q3BSP_TraceLineOfSight(), Mod_VBSP_LoadEdges(), Mod_VBSP_LoadEntities(), Mod_VBSP_LoadFaces(), Mod_VBSP_LoadPlanes(), Mod_VBSP_LoadSurfedges(), Mod_VBSP_LoadTexinfo(), Mod_VBSP_LoadTextures(), Mod_VBSP_LoadVertexes(), MSG_InitReadBuffer(), MSG_ReadLittleLong(), NULL, offset, R_AllocTexturePool(), R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), R_Mod_GetLightInfo(), and size.

Mod_VertexRangeFromElements()

void Mod_VertexRangeFromElements	(	int	numelements,
		const int *	elements,
		int *	firstvertexpointer,
		int *	lastvertexpointer )

Definition at line 2865 of file model_shared.c.

{
    int i, e;
    int firstvertex, lastvertex;
    if (numelements > 0 && elements)
    {
        firstvertex = lastvertex = elements[0];
        for (i = 1;i < numelements;i++)
        {
            e = elements[i];
            firstvertex = min(firstvertex, e);
            lastvertex = max(lastvertex, e);
        }
    }
    else
        firstvertex = lastvertex = 0;
    if (firstvertexpointer)
        *firstvertexpointer = firstvertex;
    if (lastvertexpointer)
        *lastvertexpointer = lastvertex;
}

References i, max, and min.

Mod_ZYMOTICMODEL_Load()

void Mod_ZYMOTICMODEL_Load	(	model_t *	mod,
		void *	buffer,
		void *	bufferend )

Definition at line 1768 of file model_alias.c.

{
    zymtype1header_t *pinmodel, *pheader;
    unsigned char *pbase;
    int i, j, k, numposes, meshvertices, meshtriangles, *bonecount, *vertbonecounts, count, *renderlist, *renderlistend, *outelements;
    float modelradius, corner[2], *poses, *intexcoord2f, *outtexcoord2f, *bonepose, f, biggestorigin, tempvec[3], modelscale;
    zymvertex_t *verts, *vertdata;
    zymscene_t *scene;
    zymbone_t *bone;
    char *shadername;
    skinfile_t *skinfiles;
    unsigned char *data;
    msurface_t *surface;
 
    pinmodel = (zymtype1header_t *)buffer;
    pbase = (unsigned char *)buffer;
    if (memcmp(pinmodel->id, "ZYMOTICMODEL", 12))
        Host_Error ("Mod_ZYMOTICMODEL_Load: %s is not a zymotic model", loadmodel->name);
    if (BigLong(pinmodel->type) != 1)
        Host_Error ("Mod_ZYMOTICMODEL_Load: only type 1 (skeletal pose) models are currently supported (name = %s)", loadmodel->name);
 
    loadmodel->modeldatatypestring = "ZYM";
 
    loadmodel->type = mod_alias;
    loadmodel->synctype = ST_RAND;
 
    // byteswap header
    pheader = pinmodel;
    pheader->type = BigLong(pinmodel->type);
    pheader->filesize = BigLong(pinmodel->filesize);
    pheader->mins[0] = BigFloat(pinmodel->mins[0]);
    pheader->mins[1] = BigFloat(pinmodel->mins[1]);
    pheader->mins[2] = BigFloat(pinmodel->mins[2]);
    pheader->maxs[0] = BigFloat(pinmodel->maxs[0]);
    pheader->maxs[1] = BigFloat(pinmodel->maxs[1]);
    pheader->maxs[2] = BigFloat(pinmodel->maxs[2]);
    pheader->radius = BigFloat(pinmodel->radius);
    pheader->numverts = BigLong(pinmodel->numverts);
    pheader->numtris = BigLong(pinmodel->numtris);
    pheader->numshaders = BigLong(pinmodel->numshaders);
    pheader->numbones = BigLong(pinmodel->numbones);
    pheader->numscenes = BigLong(pinmodel->numscenes);
    pheader->lump_scenes.start = BigLong(pinmodel->lump_scenes.start);
    pheader->lump_scenes.length = BigLong(pinmodel->lump_scenes.length);
    pheader->lump_poses.start = BigLong(pinmodel->lump_poses.start);
    pheader->lump_poses.length = BigLong(pinmodel->lump_poses.length);
    pheader->lump_bones.start = BigLong(pinmodel->lump_bones.start);
    pheader->lump_bones.length = BigLong(pinmodel->lump_bones.length);
    pheader->lump_vertbonecounts.start = BigLong(pinmodel->lump_vertbonecounts.start);
    pheader->lump_vertbonecounts.length = BigLong(pinmodel->lump_vertbonecounts.length);
    pheader->lump_verts.start = BigLong(pinmodel->lump_verts.start);
    pheader->lump_verts.length = BigLong(pinmodel->lump_verts.length);
    pheader->lump_texcoords.start = BigLong(pinmodel->lump_texcoords.start);
    pheader->lump_texcoords.length = BigLong(pinmodel->lump_texcoords.length);
    pheader->lump_render.start = BigLong(pinmodel->lump_render.start);
    pheader->lump_render.length = BigLong(pinmodel->lump_render.length);
    pheader->lump_shaders.start = BigLong(pinmodel->lump_shaders.start);
    pheader->lump_shaders.length = BigLong(pinmodel->lump_shaders.length);
    pheader->lump_trizone.start = BigLong(pinmodel->lump_trizone.start);
    pheader->lump_trizone.length = BigLong(pinmodel->lump_trizone.length);
 
    if (pheader->numtris < 1 || pheader->numverts < 3 || pheader->numshaders < 1)
    {
        Con_Printf("%s has no geometry\n", loadmodel->name);
        return;
    }
    if (pheader->numscenes < 1 || pheader->lump_poses.length < (int)sizeof(float[3][4]))
    {
        Con_Printf("%s has no animations\n", loadmodel->name);
        return;
    }
 
    loadmodel->Draw = R_Mod_Draw;
    loadmodel->DrawDepth = R_Mod_DrawDepth;
    loadmodel->DrawDebug = R_Mod_DrawDebug;
    loadmodel->DrawPrepass = R_Mod_DrawPrepass;
    loadmodel->CompileShadowMap = R_Mod_CompileShadowMap;
    loadmodel->DrawShadowMap = R_Mod_DrawShadowMap;
    loadmodel->DrawLight = R_Mod_DrawLight;
    loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
    loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
    loadmodel->PointSuperContents = NULL;
    loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
 
    loadmodel->numframes = pheader->numscenes;
    loadmodel->num_surfaces = pheader->numshaders;
 
    skinfiles = Mod_LoadSkinFiles();
    if (loadmodel->numskins < 1)
        loadmodel->numskins = 1;
 
    // make skinscenes for the skins (no groups)
    loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
    for (i = 0;i < loadmodel->numskins;i++)
    {
        loadmodel->skinscenes[i].firstframe = i;
        loadmodel->skinscenes[i].framecount = 1;
        loadmodel->skinscenes[i].loop = true;
        loadmodel->skinscenes[i].framerate = 10;
    }
 
    // model bbox
    // LadyHavoc: actually we blow this away later with Mod_Alias_CalculateBoundingBox()
    modelradius = pheader->radius;
    for (i = 0;i < 3;i++)
    {
        loadmodel->normalmins[i] = pheader->mins[i];
        loadmodel->normalmaxs[i] = pheader->maxs[i];
        loadmodel->rotatedmins[i] = -modelradius;
        loadmodel->rotatedmaxs[i] = modelradius;
    }
    corner[0] = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0]));
    corner[1] = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1]));
    loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = sqrt(corner[0]*corner[0]+corner[1]*corner[1]);
    if (loadmodel->yawmaxs[0] > modelradius)
        loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = modelradius;
    loadmodel->yawmins[0] = loadmodel->yawmins[1] = -loadmodel->yawmaxs[0];
    loadmodel->yawmins[2] = loadmodel->normalmins[2];
    loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2];
    loadmodel->radius = modelradius;
    loadmodel->radius2 = modelradius * modelradius;
 
    // go through the lumps, swapping things
 
    //zymlump_t lump_scenes; // zymscene_t scene[numscenes]; // name and other information for each scene (see zymscene struct)
    loadmodel->animscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numframes);
    scene = (zymscene_t *) (pheader->lump_scenes.start + pbase);
    numposes = pheader->lump_poses.length / pheader->numbones / sizeof(float[3][4]);
    for (i = 0;i < pheader->numscenes;i++)
    {
        memcpy(loadmodel->animscenes[i].name, scene->name, 32);
        loadmodel->animscenes[i].firstframe = BigLong(scene->start);
        loadmodel->animscenes[i].framecount = BigLong(scene->length);
        loadmodel->animscenes[i].framerate = BigFloat(scene->framerate);
        loadmodel->animscenes[i].loop = (BigLong(scene->flags) & ZYMSCENEFLAG_NOLOOP) == 0;
        if ((unsigned int) loadmodel->animscenes[i].firstframe >= (unsigned int) numposes)
            Host_Error("%s scene->firstframe (%i) >= numposes (%i)", loadmodel->name, loadmodel->animscenes[i].firstframe, numposes);
        if ((unsigned int) loadmodel->animscenes[i].firstframe + (unsigned int) loadmodel->animscenes[i].framecount > (unsigned int) numposes)
            Host_Error("%s scene->firstframe (%i) + framecount (%i) >= numposes (%i)", loadmodel->name, loadmodel->animscenes[i].firstframe, loadmodel->animscenes[i].framecount, numposes);
        if (loadmodel->animscenes[i].framerate < 0)
            Host_Error("%s scene->framerate (%f) < 0", loadmodel->name, loadmodel->animscenes[i].framerate);
        scene++;
    }
 
    //zymlump_t lump_bones; // zymbone_t bone[numbones];
    loadmodel->num_bones = pheader->numbones;
    loadmodel->data_bones = (aliasbone_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_bones * sizeof(aliasbone_t));
    bone = (zymbone_t *) (pheader->lump_bones.start + pbase);
    for (i = 0;i < pheader->numbones;i++)
    {
        memcpy(loadmodel->data_bones[i].name, bone[i].name, sizeof(bone[i].name));
        loadmodel->data_bones[i].flags = BigLong(bone[i].flags);
        loadmodel->data_bones[i].parent = BigLong(bone[i].parent);
        if (loadmodel->data_bones[i].parent >= i)
            Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
    }
 
    //zymlump_t lump_vertbonecounts; // int vertbonecounts[numvertices]; // how many bones influence each vertex (separate mainly to make this compress better)
    vertbonecounts = (int *)Mem_Alloc(loadmodel->mempool, pheader->numverts * sizeof(int));
    bonecount = (int *) (pheader->lump_vertbonecounts.start + pbase);
    for (i = 0;i < pheader->numverts;i++)
    {
        vertbonecounts[i] = BigLong(bonecount[i]);
        if (vertbonecounts[i] != 1)
            Host_Error("%s bonecount[%i] != 1 (vertex weight support is impossible in this format)", loadmodel->name, i);
    }
 
    loadmodel->num_poses = pheader->lump_poses.length / sizeof(float[3][4]) / loadmodel->num_bones;
 
    meshvertices = pheader->numverts;
    meshtriangles = pheader->numtris;
 
    loadmodel->submodelsurfaces_start = 0;
    loadmodel->submodelsurfaces_end = loadmodel->num_surfaces;
    loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
    loadmodel->num_texturesperskin = loadmodel->num_surfaces;
    loadmodel->surfmesh.num_vertices = meshvertices;
    loadmodel->surfmesh.num_triangles = meshtriangles;
    loadmodel->surfmesh.num_blends = 0;
    loadmodel->surfmesh.data_blendweights = NULL;
 
    // do most allocations as one merged chunk
    // This is only robust for C standard types!
    data = (unsigned char *)Mem_Alloc(loadmodel->mempool,
        loadmodel->num_surfaces * sizeof(int)
        + meshtriangles * sizeof(int[3])
        + (meshvertices <= 65536 ? loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]) : 0)
        + meshvertices * (sizeof(float[14]) + sizeof(unsigned short) + sizeof(unsigned char[2][4]))
        + loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7])
        + loadmodel->num_bones * sizeof(float[12]));
    // Pointers must be taken in descending order of alignment requirement!
    loadmodel->surfmesh.data_vertex3f          = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_svector3f         = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_tvector3f         = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_normal3f          = (float *)data; data += meshvertices * sizeof(float[3]);
    loadmodel->surfmesh.data_texcoordtexture2f = (float *)data; data += meshvertices * sizeof(float[2]);
    loadmodel->data_baseboneposeinverse        = (float *)data; data += loadmodel->num_bones * sizeof(float[12]);
    loadmodel->modelsurfaces_sorted              = (int *)data; data += loadmodel->num_surfaces * sizeof(int);
    loadmodel->surfmesh.data_element3i           = (int *)data; data += meshtriangles * sizeof(int[3]);
    loadmodel->surfmesh.blends        = (unsigned short *)data; data += meshvertices * sizeof(unsigned short);
    if (loadmodel->surfmesh.num_vertices <= 65536)
    {
        loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
    }
    loadmodel->data_poses7s                            = (short *)data; data += loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]);
    loadmodel->surfmesh.data_skeletalindex4ub  = (unsigned char *)data; data += meshvertices * sizeof(unsigned char[4]);
    loadmodel->surfmesh.data_skeletalweight4ub = (unsigned char *)data; data += meshvertices * sizeof(unsigned char[4]);
    // Struct alignment requirements could change so we can't assume them here
    // otherwise a safe-looking commit could introduce undefined behaviour!
    loadmodel->data_surfaces = Mem_AllocType(loadmodel->mempool, msurface_t, loadmodel->num_surfaces * sizeof(msurface_t));
    loadmodel->data_textures = Mem_AllocType(loadmodel->mempool, texture_t, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t));
 
    //zymlump_t lump_poses; // float pose[numposes][numbones][3][4]; // animation data
    poses = (float *) (pheader->lump_poses.start + pbase);
    // figure out scale of model from root bone, for compatibility with old zmodel versions
    tempvec[0] = BigFloat(poses[0]);
    tempvec[1] = BigFloat(poses[1]);
    tempvec[2] = BigFloat(poses[2]);
    modelscale = VectorLength(tempvec);
    biggestorigin = 0;
    for (i = 0;i < loadmodel->num_bones * numposes * 12;i++)
    {
        f = fabs(BigFloat(poses[i]));
        biggestorigin = max(biggestorigin, f);
    }
    loadmodel->num_posescale = biggestorigin / 32767.0f;
    loadmodel->num_poseinvscale = 1.0f / loadmodel->num_posescale;
    for (i = 0;i < numposes;i++)
    {
        const float *frameposes = (float *) (pheader->lump_poses.start + pbase) + 12*i*loadmodel->num_bones;
        for (j = 0;j < loadmodel->num_bones;j++)
        {
            float pose[12];
            matrix4x4_t posematrix;
            for (k = 0;k < 12;k++)
                pose[k] = BigFloat(frameposes[j*12+k]);
            //if (j < loadmodel->num_bones)
            //  Con_Printf("%s: bone %i = %f %f %f %f : %f %f %f %f : %f %f %f %f : scale = %f\n", loadmodel->name, j, pose[0], pose[1], pose[2], pose[3], pose[4], pose[5], pose[6], pose[7], pose[8], pose[9], pose[10], pose[11], VectorLength(pose));
            // scale child bones to match the root scale
            if (loadmodel->data_bones[j].parent >= 0)
            {
                pose[3] *= modelscale;
                pose[7] *= modelscale;
                pose[11] *= modelscale;
            }
            // normalize rotation matrix
            VectorNormalize(pose + 0);
            VectorNormalize(pose + 4);
            VectorNormalize(pose + 8);
            Matrix4x4_FromArray12FloatD3D(&posematrix, pose);
            Matrix4x4_ToBonePose7s(&posematrix, loadmodel->num_poseinvscale, loadmodel->data_poses7s + 7*(i*loadmodel->num_bones+j));
        }
    }
 
    //zymlump_t lump_verts; // zymvertex_t vert[numvertices]; // see vertex struct
    verts = (zymvertex_t *)Mem_Alloc(loadmodel->mempool, pheader->lump_verts.length);
    vertdata = (zymvertex_t *) (pheader->lump_verts.start + pbase);
    // reconstruct frame 0 matrices to allow reconstruction of the base mesh
    // (converting from weight-blending skeletal animation to
    //  deformation-based skeletal animation)
    bonepose = (float *)Z_Malloc(loadmodel->num_bones * sizeof(float[12]));
    for (i = 0;i < loadmodel->num_bones;i++)
    {
        float m[12];
        for (k = 0;k < 12;k++)
            m[k] = BigFloat(poses[i*12+k]);
        if (loadmodel->data_bones[i].parent >= 0)
            R_ConcatTransforms(bonepose + 12 * loadmodel->data_bones[i].parent, m, bonepose + 12 * i);
        else
            for (k = 0;k < 12;k++)
                bonepose[12*i+k] = m[k];
    }
    for (j = 0;j < pheader->numverts;j++)
    {
        // this format really should have had a per vertexweight weight value...
        // but since it does not, the weighting is completely ignored and
        // only one weight is allowed per vertex
        int boneindex = BigLong(vertdata[j].bonenum);
        const float *m = bonepose + 12 * boneindex;
        float relativeorigin[3];
        relativeorigin[0] = BigFloat(vertdata[j].origin[0]);
        relativeorigin[1] = BigFloat(vertdata[j].origin[1]);
        relativeorigin[2] = BigFloat(vertdata[j].origin[2]);
        // transform the vertex bone weight into the base mesh
        loadmodel->surfmesh.data_vertex3f[j*3+0] = relativeorigin[0] * m[0] + relativeorigin[1] * m[1] + relativeorigin[2] * m[ 2] + m[ 3];
        loadmodel->surfmesh.data_vertex3f[j*3+1] = relativeorigin[0] * m[4] + relativeorigin[1] * m[5] + relativeorigin[2] * m[ 6] + m[ 7];
        loadmodel->surfmesh.data_vertex3f[j*3+2] = relativeorigin[0] * m[8] + relativeorigin[1] * m[9] + relativeorigin[2] * m[10] + m[11];
        // store the weight as the primary weight on this vertex
        loadmodel->surfmesh.blends[j] = boneindex;
        loadmodel->surfmesh.data_skeletalindex4ub[j*4  ] = boneindex;
        loadmodel->surfmesh.data_skeletalindex4ub[j*4+1] = 0;
        loadmodel->surfmesh.data_skeletalindex4ub[j*4+2] = 0;
        loadmodel->surfmesh.data_skeletalindex4ub[j*4+3] = 0;
        loadmodel->surfmesh.data_skeletalweight4ub[j*4  ] = 255;
        loadmodel->surfmesh.data_skeletalweight4ub[j*4+1] = 0;
        loadmodel->surfmesh.data_skeletalweight4ub[j*4+2] = 0;
        loadmodel->surfmesh.data_skeletalweight4ub[j*4+3] = 0;
    }
    Z_Free(bonepose);
    // normals and tangents are calculated after elements are loaded
 
    //zymlump_t lump_texcoords; // float texcoords[numvertices][2];
    outtexcoord2f = loadmodel->surfmesh.data_texcoordtexture2f;
    intexcoord2f = (float *) (pheader->lump_texcoords.start + pbase);
    for (i = 0;i < pheader->numverts;i++)
    {
        outtexcoord2f[i*2+0] = BigFloat(intexcoord2f[i*2+0]);
        // flip T coordinate for OpenGL
        outtexcoord2f[i*2+1] = 1 - BigFloat(intexcoord2f[i*2+1]);
    }
 
    //zymlump_t lump_trizone; // byte trizone[numtris]; // see trizone explanation
    //loadmodel->alias.zymdata_trizone = Mem_Alloc(loadmodel->mempool, pheader->numtris);
    //memcpy(loadmodel->alias.zymdata_trizone, (void *) (pheader->lump_trizone.start + pbase), pheader->numtris);
 
    //zymlump_t lump_shaders; // char shadername[numshaders][32]; // shaders used on this model
    //zymlump_t lump_render; // int renderlist[rendersize]; // sorted by shader with run lengths (int count), shaders are sequentially used, each run can be used with glDrawElements (each triangle is 3 int indices)
    // byteswap, validate, and swap winding order of tris
    count = pheader->numshaders * sizeof(int) + pheader->numtris * sizeof(int[3]);
    if (pheader->lump_render.length != count)
        Host_Error("%s renderlist is wrong size (%i bytes, should be %i bytes)", loadmodel->name, pheader->lump_render.length, count);
    renderlist = (int *) (pheader->lump_render.start + pbase);
    renderlistend = (int *) ((unsigned char *) renderlist + pheader->lump_render.length);
    meshtriangles = 0;
    for (i = 0;i < loadmodel->num_surfaces;i++)
    {
        int firstvertex, lastvertex;
        if (renderlist >= renderlistend)
            Host_Error("%s corrupt renderlist (wrong size)", loadmodel->name);
        count = BigLong(*renderlist);renderlist++;
        if (renderlist + count * 3 > renderlistend || (i == pheader->numshaders - 1 && renderlist + count * 3 != renderlistend))
            Host_Error("%s corrupt renderlist (wrong size)", loadmodel->name);
 
        loadmodel->modelsurfaces_sorted[i] = i;
        surface = loadmodel->data_surfaces + i;
        surface->texture = loadmodel->data_textures + i;
        surface->num_firsttriangle = meshtriangles;
        surface->num_triangles = count;
        meshtriangles += surface->num_triangles;
 
        // load the elements
        outelements = loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3;
        for (j = 0;j < surface->num_triangles;j++, renderlist += 3)
        {
            outelements[j*3+2] = BigLong(renderlist[0]);
            outelements[j*3+1] = BigLong(renderlist[1]);
            outelements[j*3+0] = BigLong(renderlist[2]);
        }
        // validate the elements and find the used vertex range
        firstvertex = meshvertices;
        lastvertex = 0;
        for (j = 0;j < surface->num_triangles * 3;j++)
        {
            if ((unsigned int)outelements[j] >= (unsigned int)meshvertices)
                Host_Error("%s corrupt renderlist (out of bounds index)", loadmodel->name);
            firstvertex = min(firstvertex, outelements[j]);
            lastvertex = max(lastvertex, outelements[j]);
        }
        surface->num_firstvertex = firstvertex;
        surface->num_vertices = lastvertex + 1 - firstvertex;
 
        // since zym models do not have named sections, reuse their shader
        // name as the section name
        shadername = (char *) (pheader->lump_shaders.start + pbase) + i * 32;
        Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + i, skinfiles, shadername, shadername);
    }
    Mod_FreeSkinFiles(skinfiles);
    Mem_Free(vertbonecounts);
    Mem_Free(verts);
    Mod_MakeSortedSurfaces(loadmodel);
 
    // compute all the mesh information that was not loaded from the file
    if (loadmodel->surfmesh.data_element3s)
        for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
            loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
    Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
    Mod_BuildBaseBonePoses();
    Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0);
    Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, r_smoothnormals_areaweighting.integer != 0);
    loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
    if(mod_alias_force_animated.string[0])
        loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
 
    // Always make a BIH for the first frame, we can use it where possible.
    Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
    if (!loadmodel->surfmesh.isanimated)
    {
        loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
        loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
        loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
        loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
        loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
    }
}

References model_t::AnimateVertices, model_t::animscenes, BigFloat, BigLong, surfmesh_t::blends, buffer, model_t::collision_bih, model_t::CompileShadowMap, Con_Printf(), count, data, model_t::data_baseboneposeinverse, surfmesh_t::data_blendweights, model_t::data_bones, surfmesh_t::data_element3i, surfmesh_t::data_element3s, surfmesh_t::data_normal3f, model_t::data_poses7s, surfmesh_t::data_skeletalindex4ub, surfmesh_t::data_skeletalweight4ub, model_t::data_surfaces, surfmesh_t::data_svector3f, surfmesh_t::data_texcoordtexture2f, model_t::data_textures, surfmesh_t::data_tvector3f, surfmesh_t::data_vertex3f, model_t::Draw, model_t::DrawDebug, model_t::DrawDepth, model_t::DrawLight, model_t::DrawPrepass, model_t::DrawShadowMap, f, fabs(), zymtype1header_t::filesize, animscene_t::firstframe, aliasbone_t::flags, flags, zymscene_t::flags, animscene_t::framecount, animscene_t::framerate, zymscene_t::framerate, Host_Error(), i, zymtype1header_t::id, int(), cvar_t::integer, surfmesh_t::isanimated, zymlump_t::length, zymscene_t::length, loadmodel, animscene_t::loop, zymtype1header_t::lump_bones, zymtype1header_t::lump_poses, zymtype1header_t::lump_render, zymtype1header_t::lump_scenes, zymtype1header_t::lump_shaders, zymtype1header_t::lump_texcoords, zymtype1header_t::lump_trizone, zymtype1header_t::lump_vertbonecounts, zymtype1header_t::lump_verts, Matrix4x4_FromArray12FloatD3D(), Matrix4x4_ToBonePose7s(), max, zymtype1header_t::maxs, Mem_Alloc, Mem_AllocType, Mem_Free, model_t::mempool, min, zymtype1header_t::mins, mod_alias, Mod_Alias_CalculateBoundingBox(), mod_alias_force_animated, Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildBaseBonePoses(), Mod_BuildNormals(), Mod_BuildTextureVectorsFromNormals(), Mod_CollisionBIH_PointSuperContents_Mesh(), Mod_CollisionBIH_TraceBox(), Mod_CollisionBIH_TraceBrush(), Mod_CollisionBIH_TraceLine(), Mod_CollisionBIH_TracePoint_Mesh(), Mod_FreeSkinFiles(), Mod_LoadSkinFiles(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MDLMD2MD3_TraceBox(), Mod_MDLMD2MD3_TraceLine(), Mod_Skeletal_AnimateVertices(), Mod_ValidateElements(), model_t::modeldatatypestring, model_t::modelsurfaces_sorted, aliasbone_t::name, animscene_t::name, model_t::name, zymbone_t::name, zymscene_t::name, model_t::normalmaxs, model_t::normalmins, NULL, surfmesh_t::num_blends, model_t::num_bones, msurface_t::num_firsttriangle, msurface_t::num_firstvertex, model_t::num_poseinvscale, model_t::num_poses, model_t::num_posescale, model_t::num_surfaces, model_t::num_textures, model_t::num_texturesperskin, msurface_t::num_triangles, surfmesh_t::num_triangles, msurface_t::num_vertices, surfmesh_t::num_vertices, zymtype1header_t::numbones, model_t::numframes, zymtype1header_t::numscenes, zymtype1header_t::numshaders, model_t::numskins, zymtype1header_t::numtris, zymtype1header_t::numverts, origin, aliasbone_t::parent, model_t::PointSuperContents, R_ConcatTransforms(), R_Mod_CompileShadowMap(), R_Mod_Draw(), R_Mod_DrawDebug(), R_Mod_DrawDepth(), R_Mod_DrawLight(), R_Mod_DrawPrepass(), R_Mod_DrawShadowMap(), r_smoothnormals_areaweighting, model_t::radius, zymtype1header_t::radius, model_t::radius2, model_t::rotatedmaxs, model_t::rotatedmins, model_t::skinscenes, sqrt(), ST_RAND, zymlump_t::start, zymscene_t::start, cvar_t::string, model_t::submodelsurfaces_end, model_t::submodelsurfaces_start, model_t::surfmesh, model_t::synctype, msurface_t::texture, model_t::TraceBox, model_t::TraceBrush, model_t::TraceLine, model_t::TracePoint, model_t::type, zymtype1header_t::type, VectorLength, VectorNormalize, model_t::yawmaxs, model_t::yawmins, Z_Free, Z_Malloc, and ZYMSCENEFLAG_NOLOOP.

R_Mod_CompileShadowMap()

void R_Mod_CompileShadowMap	(	struct entity_render_s *	ent,
		vec3_t	relativelightorigin,
		vec3_t	relativelightdirection,
		float	lightradius,
		int	numsurfaces,
		const int *	surfacelist )

R_Mod_Draw()

void R_Mod_Draw

(

struct entity_render_s *

ent

)

R_Mod_DrawAddWaterPlanes()

void R_Mod_DrawAddWaterPlanes

(

struct entity_render_s *

ent

)

R_Mod_DrawDebug()

void R_Mod_DrawDebug

(

struct entity_render_s *

ent

)

R_Mod_DrawDepth()

void R_Mod_DrawDepth

(

struct entity_render_s *

ent

)

R_Mod_DrawLight()

void R_Mod_DrawLight	(	struct entity_render_s *	ent,
		int	numsurfaces,
		const int *	surfacelist,
		const unsigned char *	trispvs )

R_Mod_DrawPrepass()

void R_Mod_DrawPrepass

(

struct entity_render_s *

ent

)

R_Mod_DrawShadowMap()

void R_Mod_DrawShadowMap	(	int	side,
		struct entity_render_s *	ent,
		const vec3_t	relativelightorigin,
		const vec3_t	relativelightdirection,
		float	lightradius,
		int	modelnumsurfaces,
		const int *	modelsurfacelist,
		const unsigned char *	surfacesides,
		const vec3_t	lightmins,
		const vec3_t	lightmaxs )

R_Mod_DrawSky()

void R_Mod_DrawSky

(

struct entity_render_s *

ent

)

R_Mod_GetLightInfo()

void R_Mod_GetLightInfo	(	struct entity_render_s *	ent,
		vec3_t	relativelightorigin,
		float	lightradius,
		vec3_t	outmins,
		vec3_t	outmaxs,
		int *	outleaflist,
		unsigned char *	outleafpvs,
		int *	outnumleafspointer,
		int *	outsurfacelist,
		unsigned char *	outsurfacepvs,
		int *	outnumsurfacespointer,
		unsigned char *	outshadowtrispvs,
		unsigned char *	outlighttrispvs,
		unsigned char *	visitingleafpvs,
		int	numfrustumplanes,
		const mplane_t *	frustumplanes,
		qbool	noocclusion )

Variable Documentation

loadmodel

model_t* loadmodel

extern

Definition at line 598 of file model_shared.h.

Referenced by Mod_Alias_CalculateBoundingBox(), Mod_Alias_MorphMesh_CompileFrames(), Mod_AllocSurfMesh(), Mod_BSP_DecompressVis(), Mod_BSP_FinalizePortals(), Mod_BSP_LoadNodes_RecursiveSetParent(), Mod_BSP_LoadSubmodels(), Mod_BSP_MakePortals(), Mod_BSP_RecursiveNodePortals(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_BuildBaseBonePoses(), Mod_BuildVBOs(), Mod_DARKPLACESMODEL_Load(), Mod_GenerateLightmaps(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDP3_Load(), Mod_IDS2_Load(), Mod_IDSP_Load(), Mod_INTERQUAKEMODEL_Load(), Mod_LoadModel(), Mod_LoadSkinFiles(), Mod_LoadTextureFromQ3Shader(), Mod_MakeCollisionBIH(), Mod_MakeSortedSurfaces(), Mod_MDL_LoadFrames(), Mod_OBJ_Load(), Mod_PSKMODEL_Load(), Mod_Q1BSP_CheckWaterAlphaSupport(), Mod_Q1BSP_Load(), Mod_Q1BSP_LoadClipnodes(), Mod_Q1BSP_LoadEdges(), Mod_Q1BSP_LoadEntities(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadLeaffaces(), Mod_Q1BSP_LoadLeafs(), Mod_Q1BSP_LoadLighting(), Mod_Q1BSP_LoadMapBrushes(), Mod_Q1BSP_LoadNodes(), Mod_Q1BSP_LoadPlanes(), Mod_Q1BSP_LoadSplitSky(), Mod_Q1BSP_LoadSurfedges(), Mod_Q1BSP_LoadTexinfo(), Mod_Q1BSP_LoadTextures(), Mod_Q1BSP_LoadVertexes(), Mod_Q1BSP_LoadVisibility(), Mod_Q1BSP_MakeHull0(), Mod_Q1BSP_ParseWadsFromEntityLump(), Mod_Q2BSP_Load(), Mod_Q2BSP_LoadBrushes(), Mod_Q2BSP_LoadBrushSides(), Mod_Q2BSP_LoadLeafBrushes(), Mod_Q2BSP_LoadLeafs(), Mod_Q2BSP_LoadLighting(), Mod_Q2BSP_LoadNodes(), Mod_Q2BSP_LoadTexinfo(), Mod_Q2BSP_LoadVisibility(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadBrushes(), Mod_Q3BSP_LoadBrushSides(), Mod_Q3BSP_LoadBrushSides_IG(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadEntities(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLeafBrushes(), Mod_Q3BSP_LoadLeafFaces(), Mod_Q3BSP_LoadLeafs(), Mod_Q3BSP_LoadLightGrid(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadModels(), Mod_Q3BSP_LoadNodes(), Mod_Q3BSP_LoadPlanes(), Mod_Q3BSP_LoadPVS(), Mod_Q3BSP_LoadTextures(), Mod_Q3BSP_LoadTriangles(), Mod_Q3BSP_LoadVertices(), Mod_Q3BSP_RecursiveFindNumLeafs(), Mod_Sprite_SharedSetup(), Mod_SpriteSetupTexture(), Mod_VBSP_LoadEdges(), Mod_VBSP_LoadEntities(), Mod_VBSP_LoadFaces(), Mod_VBSP_LoadPlanes(), Mod_VBSP_LoadSurfedges(), Mod_VBSP_LoadTexinfo(), Mod_VBSP_LoadVertexes(), and Mod_ZYMOTICMODEL_Load().

loadname

char loadname[32]

extern

mod_base

unsigned char* mod_base

extern

Definition at line 682 of file model_shared.c.

Referenced by Mod_Q3BSP_Load(), Mod_Q3BSP_LoadBrushes(), Mod_Q3BSP_LoadBrushSides(), Mod_Q3BSP_LoadBrushSides_IG(), Mod_Q3BSP_LoadEffects(), Mod_Q3BSP_LoadEntities(), Mod_Q3BSP_LoadFaces(), Mod_Q3BSP_LoadLeafBrushes(), Mod_Q3BSP_LoadLeafFaces(), Mod_Q3BSP_LoadLeafs(), Mod_Q3BSP_LoadLightGrid(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadModels(), Mod_Q3BSP_LoadNodes(), Mod_Q3BSP_LoadPlanes(), Mod_Q3BSP_LoadPVS(), Mod_Q3BSP_LoadTextures(), Mod_Q3BSP_LoadTriangles(), and Mod_Q3BSP_LoadVertices().

mod_noshader_default_offsetmapping

struct cvar_s mod_noshader_default_offsetmapping

extern

Definition at line 51 of file model_brush.c.

{CF_CLIENT | CF_ARCHIVE, "mod_noshader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces that are not using q3 shader files"};

Referenced by Mod_BrushInit(), Mod_LoadCustomMaterial(), and Mod_LoadTextureFromQ3Shader().

mod_q3bsp_lightgrid_bsp_surfaces

struct cvar_s mod_q3bsp_lightgrid_bsp_surfaces

extern

Definition at line 50 of file model_brush.c.

{CF_CLIENT, "mod_q3bsp_lightgrid_bsp_surfaces", "0", "apply lightgrid lighting to bsp models other than the world rather than using their lightmaps (experimental/debug tool)"};

Referenced by CL_UpdateEntityShading_Entity(), and Mod_BrushInit().

mod_q3bsp_lightgrid_texture

struct cvar_s mod_q3bsp_lightgrid_texture

extern

Definition at line 48 of file model_brush.c.

{CF_CLIENT, "mod_q3bsp_lightgrid_texture", "1", "directly apply the lightgrid as a global texture rather than only reading it at the entity origin"};

Referenced by CL_UpdateEntityShading_Entity(), Mod_BrushInit(), and Mod_Q3BSP_LoadLightGrid().

mod_q3bsp_lightgrid_world_surfaces

struct cvar_s mod_q3bsp_lightgrid_world_surfaces

extern

Definition at line 49 of file model_brush.c.

{CF_CLIENT, "mod_q3bsp_lightgrid_world_surfaces", "0", "apply lightgrid lighting to the world bsp geometry rather than using lightmaps (experimental/debug tool)"};

Referenced by CL_UpdateEntityShading_Entity(), and Mod_BrushInit().

mod_q3shader_default_offsetmapping

struct cvar_s mod_q3shader_default_offsetmapping

extern

Definition at line 52 of file model_brush.c.

{CF_CLIENT | CF_ARCHIVE, "mod_q3shader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces that are using q3 shader files"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_default_offsetmapping_bias

struct cvar_s mod_q3shader_default_offsetmapping_bias

extern

Definition at line 54 of file model_brush.c.

{CF_CLIENT | CF_ARCHIVE, "mod_q3shader_default_offsetmapping_bias", "0", "default bias used for offsetmapping"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_default_offsetmapping_scale

struct cvar_s mod_q3shader_default_offsetmapping_scale

extern

Definition at line 53 of file model_brush.c.

{CF_CLIENT | CF_ARCHIVE, "mod_q3shader_default_offsetmapping_scale", "1", "default scale used for offsetmapping"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_default_polygonfactor

struct cvar_s mod_q3shader_default_polygonfactor

extern

Definition at line 55 of file model_brush.c.

{CF_CLIENT, "mod_q3shader_default_polygonfactor", "0", "biases depth values of 'polygonoffset' shaders to prevent z-fighting artifacts"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_default_polygonoffset

struct cvar_s mod_q3shader_default_polygonoffset

extern

Definition at line 56 of file model_brush.c.

{CF_CLIENT, "mod_q3shader_default_polygonoffset", "-2", "biases depth values of 'polygonoffset' shaders to prevent z-fighting artifacts"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_default_refractive_index

struct cvar_s mod_q3shader_default_refractive_index

extern

Definition at line 57 of file model_brush.c.

{CF_CLIENT, "mod_q3shader_default_refractive_index", "1.33", "angle of refraction specified as n to apply when a photon is refracted, example values are: 1.0003 = air, water = 1.333, crown glass = 1.517, flint glass = 1.655, diamond = 2.417"};

Referenced by Mod_BrushInit(), Mod_LoadTextureFromQ3Shader(), and Mod_Q1BSP_LoadTextures().

mod_q3shader_force_addalpha

struct cvar_s mod_q3shader_force_addalpha

extern

Definition at line 58 of file model_brush.c.

{CF_CLIENT, "mod_q3shader_force_addalpha", "0", "treat GL_ONE GL_ONE (or add) blendfunc as GL_SRC_ALPHA GL_ONE for compatibility with older DarkPlaces releases"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

mod_q3shader_force_terrain_alphaflag

struct cvar_s mod_q3shader_force_terrain_alphaflag

extern

Definition at line 59 of file model_brush.c.

{CF_CLIENT, "mod_q3shader_force_terrain_alphaflag", "0", "for multilayered terrain shaders force TEXF_ALPHA flag on both layers"};

Referenced by Mod_BrushInit(), and Mod_LoadQ3Shaders().

r_fullbrights

struct cvar_s r_fullbrights

extern

Definition at line 122 of file gl_rmain.c.

{CF_CLIENT | CF_ARCHIVE, "r_fullbrights", "1", "enables glowing pixels in quake textures (changes need r_restart to take effect)"};

Referenced by GL_Main_Init(), Mod_IDP0_Load(), Mod_Q1BSP_LoadTextures(), and R_LoadQWSkin().

r_mipnormalmaps

struct cvar_s r_mipnormalmaps

extern

Definition at line 31 of file model_shared.c.

{CF_CLIENT | CF_ARCHIVE, "r_mipnormalmaps", "1", "mipmaps normalmaps (turning it off looks sharper but may have aliasing)"};

Referenced by Mod_Init(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), and R_SkinFrame_LoadInternalBGRA().

r_mipskins

struct cvar_s r_mipskins

extern

Definition at line 30 of file model_shared.c.

{CF_CLIENT | CF_ARCHIVE, "r_mipskins", "0", "mipmaps model skins so they render faster in the distance and do not display noise artifacts, can cause discoloration of skins if they contain undesirable border colors"};

Referenced by Mod_BuildAliasSkinsFromSkinFiles(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_Init(), and R_LoadQWSkin().