com_mesh.c File Reference

Typedefs
typedef struct md3Frame_s	md3Frame_t
typedef struct zymlump_s	zymlump_t
typedef struct zymtype1header_s	zymtype1header_t
typedef struct zymbone_s	zymbone_t
typedef struct zymscene_s	zymscene_t
typedef struct zymvertex_s	zymvertex_t
typedef struct pskchunk_s	pskchunk_t
typedef struct pskpnts_s	pskpnts_t
typedef struct pskvtxw_s	pskvtxw_t
typedef struct pskface_s	pskface_t
typedef struct pskmatt_s	pskmatt_t
typedef struct pskpose_s	pskpose_t
typedef struct pskboneinfo_s	pskboneinfo_t
typedef struct pskrawweights_s	pskrawweights_t
typedef struct pskaniminfo_s	pskaniminfo_t
typedef struct pskanimkeys_s	pskanimkeys_t

Functions
qboolean	Mod_DoCRC (model_t *mod, char *buffer, int buffersize)
void QDECL	Mod_AccumulateTextureVectors (vecV_t *const vc, vec2_t *const tc, vec3_t *nv, vec3_t *sv, vec3_t *tv, const index_t *idx, int numidx, qboolean calcnorms)
void	Mod_AccumulateMeshTextureVectors (mesh_t *m)
void QDECL	Mod_NormaliseTextureVectors (vec3_t *n, vec3_t *s, vec3_t *t, int v, qboolean calcnorms)
void QDECL	Alias_ForceConvertBoneData (skeltype_t sourcetype, const float *sourcedata, size_t bonecount, galiasbone_t *bones, skeltype_t desttype, float *destbuffer, size_t destbonecount)
void	R_LightArraysByte_BGR (const entity_t *entity, vecV_t *coords, byte_vec4_t *colours, int vertcount, vec3_t *normals, qboolean usecolourmod)
void	R_LightArrays (const entity_t *entity, vecV_t *coords, avec4_t *colours, int vertcount, vec3_t *normals, float scale, qboolean colormod)
void	Alias_FlushCache (void)
void	Alias_Shutdown (void)
qboolean	Alias_GAliasBuildMesh (mesh_t *mesh, vbo_t **vbop, galiasinfo_t *inf, int surfnum, entity_t *e, qboolean usebones)
	if (meshcache.bonegroup !=inf->shares_bones)
	if (!e->framestate.g[FS_REG].lerpweight[0] &&!e->framestate.g[FS_REG].lerpweight[1] &&!e->framestate.g[FS_REG].lerpweight[2] &&!e->framestate.g[FS_REG].lerpweight[3]) Con_Printf("Entity with no lerp info\n")
	if (vbop)
else	if (inf->numbones)
	if (e->framestate.g[FS_REG].lerpweight[2]||e->framestate.g[FS_REG].lerpweight[3]) Con_ThrottlePrintf(&printtimer
	Alias_GAliasBuildMesh (%s)
	VectorAdd (p1, r_refdef.pvsorigin, edge1)
	VectorAdd (p2, r_refdef.pvsorigin, edge2)
	VectorAdd (p3, r_refdef.pvsorigin, edge3)
	CLQ1_DrawLine (lineshader, edge1, edge2, 0, 1, 0, 1)
	CLQ1_DrawLine (lineshader, edge2, edge3, 0, 1, 0, 1)
	CLQ1_DrawLine (lineshader, edge3, edge1, 0, 1, 0, 1)
	VectorSubtract (p1, p2, edge1)
	VectorSubtract (p3, p2, edge2)
	CrossProduct (edge1, edge2, normal)
	VectorNormalize (normal)
	if (!normal[0] &&!normal[1] &&!normal[2]) continue
	if (diststart< planedist) continue
	if (distend, planedist)
	if (frac >=trace->truefraction) continue
	for (j=0;j< 3;j++)
	CrossProduct (edge1, normal, edgenormal)
	VectorNormalize (edgenormal)
	if (DotProduct(impactpoint, edgenormal) > DotProduct(p2, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+DIST_EPSILON) continue
	CrossProduct (normal, edge2, edgenormal)
	if (DotProduct(impactpoint, edgenormal) > DotProduct(p3, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+DIST_EPSILON) continue
	VectorSubtract (p1, p3, edge3)
	CrossProduct (normal, edge3, edgenormal)
	if (DotProduct(impactpoint, edgenormal) > DotProduct(p1, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+DIST_EPSILON) continue
	VectorCopy (normal, trace->plane.normal)
qboolean	Mod_Mesh_EdictInFatPVS (struct model_s *model, const struct pvscache_s *edict, const qbyte *pvs, const int *areas)
void	Mod_Mesh_FindTouchedLeafs (struct model_s *model, struct pvscache_s *ent, const vec3_t cullmins, const vec3_t cullmaxs)
void	Mod_DestroyMesh (galiasinfo_t *galias)
void	Mod_LoadAliasShaders (model_t *mod)
int	Mod_GetNumBones (model_t *model, qboolean allowtags)
int	Mod_GetBoneRelations (model_t *model, int firstbone, int lastbone, framestate_t *fstate, float *result)
galiasbone_t *	Mod_GetBoneInfo (model_t *model, int *numbones)
int	Mod_GetBoneParent (model_t *model, int bonenum)
const char *	Mod_GetBoneName (model_t *model, int bonenum)
qboolean	Mod_GetTag (model_t *model, int tagnum, framestate_t *fstate, float *result)
int	Mod_TagNumForName (model_t *model, const char *name, int firsttag)
int	Mod_FrameNumForName (model_t *model, int surfaceidx, const char *name)
int	Mod_FrameNumForAction (model_t *model, int surfaceidx, int actionid)
qboolean	Mod_GetModelEvent (model_t *model, int animation, int eventidx, float *timestamp, int *eventcode, char **eventdata)
int	Mod_SkinNumForName (model_t *model, int surfaceidx, const char *name)
const char *	Mod_FrameNameForNum (model_t *model, int surfaceidx, int num)
qboolean	Mod_FrameInfoForNum (model_t *model, int surfaceidx, int num, char **name, int *numframes, float *duration, qboolean *loop, int *act)
shader_t *	Mod_ShaderForSkin (model_t *model, int surfaceidx, int num, float time, texnums_t **out_texnums)
const char *	Mod_SkinNameForNum (model_t *model, int surfaceidx, int num)
const char *	Mod_SurfaceNameForNum (model_t *model, int num)
float	Mod_GetFrameDuration (model_t *model, int surfaceidx, int frameno)
int	Mod_GetFrameCount (struct model_s *model)

Variables
qboolean	r_loadbumpmapping
cvar_t	r_noframegrouplerp
cvar_t	r_lerpmuzzlehack = CVARF ("r_lerpmuzzlehack", "1", CVAR_ARCHIVE)
cvar_t	mod_h2holey_bugged = CVARD ("mod_h2holey_bugged", "0", "Hexen2's holey-model flag uses index 0 as transparent (and additionally 255 in gl, due to a bug). GLQuake engines tend to have bugs that use ONLY index 255, resulting in a significant compatibility issue that can be resolved only with this shitty cvar hack.")
cvar_t	mod_halftexel = CVARD ("mod_halftexel", "1", "Offset texture coords by a half-texel, for compatibility with glquake and the majority of engine forks.")
cvar_t	mod_nomipmap = CVARD ("mod_nomipmap", "0", "Disables the use of mipmaps on quake1 mdls, consistent with its original software renderer.")
cvar_t	mod_obj_orientation = CVARD("mod_obj_orientation", "1", "Controls how the model's axis are interpreted.\n0: x=forward, z=up (Quake)\n1: x=forward, y=up\n2: z=forward, y=up")
cvar_t	mod_md5_singleanimation = CVARD("mod_md5_singleanimation", "1", "When loading an md5mesh file, also attempt to load an .md5anim file, and unpack it into individual poses. Use 0 for mods that will be precaching their own md5anims for use with skeletal objects.")
cvar_t	r_meshpitch = CVARCD ("r_meshpitch", "1", r_meshpitch_callback, "Specifies the direction of the pitch angle on mesh models formats, also affects gamecode, so do not change from its default.")
cvar_t	r_meshroll = CVARCD ("r_meshroll", "1", r_meshpitch_callback, "Specifies the direction of the roll angle on mesh models formats, also affects gamecode, so do not change from its default.")
cvar_t	dpcompat_skinfiles = CVARD ("dpcompat_skinfiles", "0", "When set, uses a nodraw shader for any unmentioned surfaces.")
cvar_t	gl_part_flame
cvar_t	r_fullbrightSkins
cvar_t	r_fb_models
cvar_t	r_noaliasshadows
cvar_t	r_skin_overlays
cvar_t	mod_md3flags
struct {
int   numcoords
vecV_t *   coords
int   numnorm
vec3_t *   norm
int   bonegroup
int   vertgroup
entity_t *   ent
boneidx_t *   bonemap
float   gpubones [MAX_BONES *12]
float   boneposebuffer1 [MAX_BONES *12]
float   boneposebuffer2 [MAX_BONES *12]
skeltype_t   bonecachetype
const float *   usebonepose
int   bonecount
qboolean   usebones
vecV_t *   acoords1
vecV_t *   acoords2
vec3_t *   anorm
vec3_t *   anorms
vec3_t *   anormt
float   lerp
vbo_t   vbo
vbo_t *   vbop
}	meshcache
	else
mesh	trneighbors = inf->ofs_trineighbours
mesh	normals_array = meshcache.norm
mesh	snormals_array = meshcache.norm+meshcache.numnorm
mesh	tnormals_array = meshcache.norm+meshcache.numnorm*2
mesh	xyz_array = meshcache.coords
return	false
float	lerpcutoff
galiasanimation_t *	g1
galiasanimation_t *	g2
int	frame1
int	frame2
float	fg1time
	n
	extend = PlaneNearest(normal, mins, maxs)
	planedist = DotProduct(p1, normal)-extend
	diststart = DotProduct(start, normal)
	distend = DotProduct(end, normal)
	frac = (diststart - planedist) / (diststart-distend)
trace	truefraction = frac
trace	endpos [0] = start[0] + frac*(end[0] - start[0])
trace plane	dist = planedist
trace	triangle_id = 1+i/3
	impacted = true
float	r_avertexnormals [NUMVERTEXNORMALS][3]
vec3_t	bytedirs [Q2NUMVERTEXNORMALS]
cvar_t	dpcompat_psa_ungroup

Typedef Documentation

md3Frame_t

typedef struct md3Frame_s md3Frame_t

pskaniminfo_t

typedef struct pskaniminfo_s pskaniminfo_t

pskanimkeys_t

typedef struct pskanimkeys_s pskanimkeys_t

pskboneinfo_t

typedef struct pskboneinfo_s pskboneinfo_t

pskchunk_t

typedef struct pskchunk_s pskchunk_t

pskface_t

typedef struct pskface_s pskface_t

pskmatt_t

typedef struct pskmatt_s pskmatt_t

pskpnts_t

typedef struct pskpnts_s pskpnts_t

pskpose_t

typedef struct pskpose_s pskpose_t

pskrawweights_t

typedef struct pskrawweights_s pskrawweights_t

pskvtxw_t

typedef struct pskvtxw_s pskvtxw_t

zymbone_t

typedef struct zymbone_s zymbone_t

zymlump_t

typedef struct zymlump_s zymlump_t

zymscene_t

typedef struct zymscene_s zymscene_t

zymtype1header_t

typedef struct zymtype1header_s zymtype1header_t

zymvertex_t

typedef struct zymvertex_s zymvertex_t

Function Documentation

Alias_FlushCache()

void Alias_FlushCache

(

void

)

Alias_ForceConvertBoneData()

void QDECL Alias_ForceConvertBoneData	(	skeltype_t	sourcetype,
		const float *	sourcedata,
		size_t	bonecount,
		galiasbone_t *	bones,
		skeltype_t	desttype,
		float *	destbuffer,
		size_t	destbonecount
	)

Alias_GAliasBuildMesh() [1/2]

Alias_GAliasBuildMesh

(

%

s

)

Alias_GAliasBuildMesh() [2/2]

qboolean Alias_GAliasBuildMesh	(	mesh_t *	mesh,
		vbo_t **	vbop,
		galiasinfo_t *	inf,
		int	surfnum,
		entity_t *	e,
		qboolean	usebones
	)

Alias_Shutdown()

void Alias_Shutdown

(

void

)

CLQ1_DrawLine() [1/3]

CLQ1_DrawLine	(	lineshader	,
		edge1	,
		edge2	,
		0	,
		1	,
		0	,
		1
	)

CLQ1_DrawLine() [2/3]

CLQ1_DrawLine	(	lineshader	,
		edge2	,
		edge3	,
		0	,
		1	,
		0	,
		1
	)

CLQ1_DrawLine() [3/3]

CLQ1_DrawLine	(	lineshader	,
		edge3	,
		edge1	,
		0	,
		1	,
		0	,
		1
	)

CrossProduct() [1/4]

CrossProduct	(	edge1	,
		edge2	,
		normal
	)

CrossProduct() [2/4]

CrossProduct	(	edge1	,
		normal	,
		edgenormal
	)

CrossProduct() [3/4]

CrossProduct	(	normal	,
		edge2	,
		edgenormal
	)

CrossProduct() [4/4]

CrossProduct	(	normal	,
		edge3	,
		edgenormal
	)

for()

for

(

)

if() [1/12]

if

(

!e->framestate.g.lerpweight &&!e->framestate.g.lerpweight &&!e->framestate.g.lerpweight &&!e->framestate.g.

lerpweight[FS_REG][0][FS_REG][1][FS_REG][2][FS_REG][3]

)

if() [2/12]

if

(

!normal &&!normal &&!

normal[0][1][2]

)

if() [3/12]

if	(	distend	,
		planedist
	)

if() [4/12]

if

(

)

if() [5/12]

if	(	DotProduct(impactpoint, edgenormal)	,
		DotProduct(p1, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+	DIST_EPSILON
	)

if() [6/12]

if	(	DotProduct(impactpoint, edgenormal)	,
		DotProduct(p2, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+	DIST_EPSILON
	)

if() [7/12]

if	(	DotProduct(impactpoint, edgenormal)	,
		DotProduct(p3, edgenormal) -PlaneNearest(edgenormal, mins, maxs)+	DIST_EPSILON
	)

if() [8/12]

if

(

e->framestate.g.lerpweight||e->framestate.g.

lerpweight[FS_REG][2][FS_REG][3]

)

&

if() [9/12]

if

(

frac >=trace->

truefraction

)

if() [10/12]

else if

(

inf->

numbones

)

if() [11/12]

if

(

meshcache.bonegroup !

= inf->shares_bones

)

if() [12/12]

if

(

vbop

)

Mod_AccumulateMeshTextureVectors()

void Mod_AccumulateMeshTextureVectors

(

mesh_t *

m

)

Mod_AccumulateTextureVectors()

void QDECL Mod_AccumulateTextureVectors	(	vecV_t *const	vc,
		vec2_t *const	tc,
		vec3_t *	nv,
		vec3_t *	sv,
		vec3_t *	tv,
		const index_t *	idx,
		int	numidx,
		qboolean	calcnorms
	)

Mod_DestroyMesh()

void Mod_DestroyMesh

(

galiasinfo_t *

galias

)

Mod_DoCRC()

qboolean Mod_DoCRC	(	model_t *	mod,
		char *	buffer,
		int	buffersize
	)

Mod_FrameInfoForNum()

qboolean Mod_FrameInfoForNum	(	model_t *	model,
		int	surfaceidx,
		int	num,
		char **	name,
		int *	numframes,
		float *	duration,
		qboolean *	loop,
		int *	act
	)

Mod_FrameNameForNum()

const char * Mod_FrameNameForNum	(	model_t *	model,
		int	surfaceidx,
		int	num
	)

Mod_FrameNumForAction()

int Mod_FrameNumForAction	(	model_t *	model,
		int	surfaceidx,
		int	actionid
	)

Mod_FrameNumForName()

int Mod_FrameNumForName	(	model_t *	model,
		int	surfaceidx,
		const char *	name
	)

Mod_GetBoneInfo()

galiasbone_t * Mod_GetBoneInfo	(	model_t *	model,
		int *	numbones
	)

Mod_GetBoneName()

const char * Mod_GetBoneName	(	model_t *	model,
		int	bonenum
	)

Mod_GetBoneParent()

int Mod_GetBoneParent	(	model_t *	model,
		int	bonenum
	)

Mod_GetBoneRelations()

int Mod_GetBoneRelations	(	model_t *	model,
		int	firstbone,
		int	lastbone,
		framestate_t *	fstate,
		float *	result
	)

Mod_GetFrameCount()

int Mod_GetFrameCount

(

struct model_s *

model

)

Mod_GetFrameDuration()

float Mod_GetFrameDuration	(	model_t *	model,
		int	surfaceidx,
		int	frameno
	)

Mod_GetModelEvent()

qboolean Mod_GetModelEvent	(	model_t *	model,
		int	animation,
		int	eventidx,
		float *	timestamp,
		int *	eventcode,
		char **	eventdata
	)

Mod_GetNumBones()

int Mod_GetNumBones	(	model_t *	model,
		qboolean	allowtags
	)

Mod_GetTag()

qboolean Mod_GetTag	(	model_t *	model,
		int	tagnum,
		framestate_t *	fstate,
		float *	result
	)

Mod_LoadAliasShaders()

void Mod_LoadAliasShaders

(

model_t *

mod

)

Mod_Mesh_EdictInFatPVS()

qboolean Mod_Mesh_EdictInFatPVS	(	struct model_s *	model,
		const struct pvscache_s *	edict,
		const qbyte *	pvs,
		const int *	areas
	)

Mod_Mesh_FindTouchedLeafs()

void Mod_Mesh_FindTouchedLeafs	(	struct model_s *	model,
		struct pvscache_s *	ent,
		const vec3_t	cullmins,
		const vec3_t	cullmaxs
	)

Mod_NormaliseTextureVectors()

void QDECL Mod_NormaliseTextureVectors	(	vec3_t *	n,
		vec3_t *	s,
		vec3_t *	t,
		int	v,
		qboolean	calcnorms
	)

Mod_ShaderForSkin()

shader_t * Mod_ShaderForSkin	(	model_t *	model,
		int	surfaceidx,
		int	num,
		float	time,
		texnums_t **	out_texnums
	)

Mod_SkinNameForNum()

const char * Mod_SkinNameForNum	(	model_t *	model,
		int	surfaceidx,
		int	num
	)

Mod_SkinNumForName()

int Mod_SkinNumForName	(	model_t *	model,
		int	surfaceidx,
		const char *	name
	)

Mod_SurfaceNameForNum()

const char * Mod_SurfaceNameForNum	(	model_t *	model,
		int	num
	)

Mod_TagNumForName()

int Mod_TagNumForName	(	model_t *	model,
		const char *	name,
		int	firsttag
	)

R_LightArrays()

void R_LightArrays	(	const entity_t *	entity,
		vecV_t *	coords,
		avec4_t *	colours,
		int	vertcount,
		vec3_t *	normals,
		float	scale,
		qboolean	colormod
	)

R_LightArraysByte_BGR()

void R_LightArraysByte_BGR	(	const entity_t *	entity,
		vecV_t *	coords,
		byte_vec4_t *	colours,
		int	vertcount,
		vec3_t *	normals,
		qboolean	usecolourmod
	)

VectorAdd() [1/3]

VectorAdd	(	p1	,
		r_refdef.	pvsorigin,
		edge1
	)

Initial value:

{
                        shader_t *lineshader = R_RegisterShader("lineshader", SUF_NONE,
                                                "{\n"
                                                        "polygonoffset\n"
                                                        "{\n"
                                                                "map $whiteimage\n"
                                                                "blendfunc add\n"
                                                                "rgbgen vertex\n"
                                                                "alphagen vertex\n"
                                                        "}\n"
                                                "}\n")

VectorAdd() [2/3]

VectorAdd	(	p2	,
		r_refdef.	pvsorigin,
		edge2
	)

VectorAdd() [3/3]

VectorAdd	(	p3	,
		r_refdef.	pvsorigin,
		edge3
	)

VectorCopy()

VectorCopy	(	normal	,
		trace->plane.	normal
	)

VectorNormalize() [1/2]

VectorNormalize

(

edgenormal

)

VectorNormalize() [2/2]

VectorNormalize

(

normal

)

VectorSubtract() [1/3]

VectorSubtract	(	p1	,
		p2	,
		edge1
	)

VectorSubtract() [2/3]

VectorSubtract	(	p1	,
		p3	,
		edge3
	)

VectorSubtract() [3/3]

VectorSubtract	(	p3	,
		p2	,
		edge2
	)

Variable Documentation

acoords1

vecV_t* acoords1

acoords2

vecV_t* acoords2

anorm

vec3_t* anorm

anorms

vec3_t* anorms

anormt

vec3_t* anormt

bonecachetype

meshcache bonecachetype = -1

bonecount

int bonecount

bonegroup

meshcache bonegroup = inf->shares_bones

bonemap

boneidx_t* bonemap

boneposebuffer1

float boneposebuffer1[MAX_BONES *12]

boneposebuffer2

float boneposebuffer2[MAX_BONES *12]

bytedirs

vec3_t bytedirs

extern

coords

vecV_t* coords

dist

trace plane dist = planedist

distend

distend = DotProduct(end, normal)

diststart

diststart = DotProduct(start, normal)

dpcompat_psa_ungroup

cvar_t dpcompat_psa_ungroup

extern

dpcompat_skinfiles

cvar_t dpcompat_skinfiles = CVARD ("dpcompat_skinfiles", "0", "When set, uses a nodraw shader for any unmentioned surfaces.")

else

else

Initial value:

{
                meshcache.usebonepose = NULL

endpos

trace endpos = start[0] + frac*(end[0] - start[0])

ent

meshcache ent = e

extend

extend = PlaneNearest(normal, mins, maxs)

false

return false

fg1time

float fg1time

frac

frac = (diststart - planedist) / (diststart-distend)

frame1

int frame1

frame2

int frame2

g1

galiasanimation_t* g1

g2

galiasanimation_t * g2

gl_part_flame

cvar_t gl_part_flame

extern

gpubones

float gpubones[MAX_BONES *12]

impacted

return impacted = true

lerp

float lerp

lerpcutoff

float lerpcutoff

struct { ... } meshcache

mod_h2holey_bugged

cvar_t mod_h2holey_bugged = CVARD ("mod_h2holey_bugged", "0", "Hexen2's holey-model flag uses index 0 as transparent (and additionally 255 in gl, due to a bug). GLQuake engines tend to have bugs that use ONLY index 255, resulting in a significant compatibility issue that can be resolved only with this shitty cvar hack.")

mod_halftexel

cvar_t mod_halftexel = CVARD ("mod_halftexel", "1", "Offset texture coords by a half-texel, for compatibility with glquake and the majority of engine forks.")

mod_md3flags

cvar_t mod_md3flags

extern

mod_md5_singleanimation

cvar_t mod_md5_singleanimation = CVARD("mod_md5_singleanimation", "1", "When loading an md5mesh file, also attempt to load an .md5anim file, and unpack it into individual poses. Use 0 for mods that will be precaching their own md5anims for use with skeletal objects.")

mod_nomipmap

cvar_t mod_nomipmap = CVARD ("mod_nomipmap", "0", "Disables the use of mipmaps on quake1 mdls, consistent with its original software renderer.")

mod_obj_orientation

cvar_t mod_obj_orientation = CVARD("mod_obj_orientation", "1", "Controls how the model's axis are interpreted.\n0: x=forward, z=up (Quake)\n1: x=forward, y=up\n2: z=forward, y=up")

n

n

norm

vec3_t* norm

normals_array

mesh normals_array = meshcache.norm

numcoords

int numcoords

numnorm

int numnorm

planedist

planedist = DotProduct(p1, normal)-extend

r_avertexnormals

float r_avertexnormals[NUMVERTEXNORMALS][3]

extern

r_fb_models

cvar_t r_fb_models

r_fullbrightSkins

cvar_t r_fullbrightSkins

r_lerpmuzzlehack

cvar_t r_lerpmuzzlehack = CVARF ("r_lerpmuzzlehack", "1", CVAR_ARCHIVE)

r_loadbumpmapping

qboolean r_loadbumpmapping

r_meshpitch

cvar_t r_meshpitch = CVARCD ("r_meshpitch", "1", r_meshpitch_callback, "Specifies the direction of the pitch angle on mesh models formats, also affects gamecode, so do not change from its default.")

r_meshroll

cvar_t r_meshroll = CVARCD ("r_meshroll", "1", r_meshpitch_callback, "Specifies the direction of the roll angle on mesh models formats, also affects gamecode, so do not change from its default.")

r_noaliasshadows

cvar_t r_noaliasshadows

extern

r_noframegrouplerp

cvar_t r_noframegrouplerp

extern

r_skin_overlays

cvar_t r_skin_overlays

extern

snormals_array

mesh snormals_array = meshcache.norm+meshcache.numnorm

tnormals_array

mesh tnormals_array = meshcache.norm+meshcache.numnorm*2

triangle_id

trace triangle_id = 1+i/3

trneighbors

mesh trneighbors = inf->ofs_trineighbours

truefraction

trace truefraction = frac

usebonepose

const float* usebonepose

usebones

qboolean usebones

vbo

vbo_t vbo

vbop

* vbop = NULL

vertgroup

meshcache vertgroup = inf->shares_verts

xyz_array

mesh xyz_array = meshcache.coords