spingle/source/gl_model.h

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2010-2014 QuakeSpasm developers

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#ifndef __MODEL__
#define __MODEL__

#include "modelgen.h"
#include "spritegn.h"

/*

d*_t structures are on-disk representations
m*_t structures are in-memory

*/

// entity effects

#define EF_BRIGHTFIELD                  1
#define EF_MUZZLEFLASH                  2
#define EF_BRIGHTLIGHT                  4
#define EF_DIMLIGHT                     8


/*
==============================================================================

BRUSH MODELS

==============================================================================
*/


//
// in memory representation
//
// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct
{
	vec3_t          position;
} mvertex_t;

#define SIDE_FRONT      0
#define SIDE_BACK       1
#define SIDE_ON         2


// plane_t structure
// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct mplane_s
{
	vec3_t  normal;
	float   dist;
	byte    type;                   // for texture axis selection and fast side tests
	byte    signbits;               // signx + signy<<1 + signz<<1
	byte    pad[2];
} mplane_t;

// ericw -- each texture has two chains, so we can clear the model chains
//          without affecting the world
typedef enum
{
	chain_world = 0,
	chain_model = 1
} texchain_t;

typedef struct texture_s
{
	char                            name[16];
	unsigned                        width, height;
	struct gltexture_s      *gltexture; //johnfitz -- pointer to gltexture
	struct gltexture_s      *fullbright; //johnfitz -- fullbright mask texture
	struct gltexture_s      *warpimage; //johnfitz -- for water animation
	bool                    update_warp; //johnfitz -- update warp this frame
	struct msurface_s       *texturechains[2];      // for texture chains
	int32_t                                 anim_total;                             // total tenths in sequence ( 0 = no)
	int32_t                                 anim_min, anim_max;             // time for this frame min <=time< max
	struct texture_s        *anim_next;             // in the animation sequence
	struct texture_s        *alternate_anims;       // bmodels in frmae 1 use these
	unsigned                        offsets[MIPLEVELS];             // four mip maps stored
} texture_t;


#define SURF_PLANEBACK          2
#define SURF_DRAWSKY            4
#define SURF_DRAWSPRITE         8
#define SURF_DRAWTURB           0x10
#define SURF_DRAWTILED          0x20
#define SURF_DRAWBACKGROUND     0x40
#define SURF_UNDERWATER         0x80
#define SURF_NOTEXTURE          0x100 //johnfitz
#define SURF_DRAWFENCE          0x200
#define SURF_DRAWLAVA           0x400
#define SURF_DRAWSLIME          0x800
#define SURF_DRAWTELE           0x1000
#define SURF_DRAWWATER          0x2000

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct
{
	uint32_t        v[2];
	uint32_t        cachededgeoffset;
} medge_t;

typedef struct
{
	float           vecs[2][4];
	float           mipadjust;
	texture_t       *texture;
	int32_t                 flags;
} mtexinfo_t;

#define VERTEXSIZE      7

typedef struct glpoly_s
{
	struct  glpoly_s        *next;
	struct  glpoly_s        *chain;
	int32_t         numverts;
	float   verts[4][VERTEXSIZE];   // variable sized (xyz s1t1 s2t2)
} glpoly_t;

typedef struct msurface_s
{
	int32_t                 visframe;               // should be drawn when node is crossed
	bool    culled;                 // johnfitz -- for frustum culling
	float           mins[3];                // johnfitz -- for frustum culling
	float           maxs[3];                // johnfitz -- for frustum culling

	mplane_t        *plane;
	int32_t                 flags;

	int32_t                 firstedge;      // look up in model->surfedges[], negative numbers
	int32_t                 numedges;       // are backwards edges

	int16_t         texturemins[2];
	int16_t         extents[2];

	int32_t                 light_s, light_t;       // gl lightmap coordinates

	glpoly_t        *polys;                         // multiple if warped
	struct  msurface_s      *texturechain;

	mtexinfo_t      *texinfo;

	int32_t         vbo_firstvert;          // index of this surface's first vert in the VBO

// lighting info
	int32_t                 dlightframe;
	uint32_t                dlightbits[(MAX_DLIGHTS + 31) >> 5];
	// int32_t is 32 bits, need an array for MAX_DLIGHTS > 32

	int32_t                 lightmaptexturenum;
	byte            styles[MAXLIGHTMAPS];
	int32_t                 cached_light[MAXLIGHTMAPS];     // values currently used in lightmap
	bool    cached_dlight;                          // true if dynamic light in cache
	byte            *samples;               // [numstyles*surfsize]
} msurface_t;

typedef struct mnode_s
{
// common with leaf
	int32_t                 contents;               // 0, to differentiate from leafs
	int32_t                 visframe;               // node needs to be traversed if current

	float           minmaxs[6];             // for bounding box culling

	struct mnode_s  *parent;

// node specific
	mplane_t        *plane;
	struct mnode_s  *children[2];

	int32_t         firstsurface;
	int32_t         numsurfaces;
} mnode_t;



typedef struct mleaf_s
{
// common with node
	int32_t                 contents;               // wil be a negative contents number
	int32_t                 visframe;               // node needs to be traversed if current

	float           minmaxs[6];             // for bounding box culling

	struct mnode_s  *parent;

// leaf specific
	byte            *compressed_vis;
	efrag_t         *efrags;

	msurface_t      **firstmarksurface;
	int32_t                 nummarksurfaces;
	int32_t                 key;                    // BSP sequence number for leaf's contents
	byte            ambient_sound_level[NUM_AMBIENTS];
} mleaf_t;

//johnfitz -- for clipnodes>32k
typedef struct mclipnode_s
{
	int32_t                 planenum;
	int32_t                 children[2]; // negative numbers are contents
} mclipnode_t;
//johnfitz

// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct
{
	mclipnode_t     *clipnodes; //johnfitz -- was dclipnode_t
	mplane_t        *planes;
	int32_t                 firstclipnode;
	int32_t                 lastclipnode;
	vec3_t          clip_mins;
	vec3_t          clip_maxs;
} hull_t;

/*
==============================================================================

SPRITE MODELS

==============================================================================
*/


// FIXME: shorten these?
typedef struct mspriteframe_s
{
	int32_t                                 width, height;
	float                           up, down, left, right;
	float                           smax, tmax; //johnfitz -- image might be padded
	struct gltexture_s      *gltexture;
} mspriteframe_t;

typedef struct
{
	int32_t                         numframes;
	float                   *intervals;
	mspriteframe_t  *frames[1];
} mspritegroup_t;

typedef struct
{
	spriteframetype_t       type;
	mspriteframe_t          *frameptr;
} mspriteframedesc_t;

typedef struct
{
	int32_t                                 type;
	int32_t                                 maxwidth;
	int32_t                                 maxheight;
	int32_t                                 numframes;
	float                           beamlength;             // remove?
	void                            *cachespot;             // remove?
	mspriteframedesc_t      frames[1];
} msprite_t;


/*
==============================================================================

ALIAS MODELS

Alias models are position independent, so the cache manager can move them.
==============================================================================
*/

//-- from RMQEngine
// split out to keep vertex sizes down
typedef struct aliasmesh_s
{
	float st[2];
	uint16_t vertindex;
} aliasmesh_t;

typedef struct meshxyz_s
{
	byte xyz[4];
	int8_t normal[4];
} meshxyz_t;

typedef struct meshst_s
{
	float st[2];
} meshst_t;
//--

typedef struct
{
	int32_t                                 firstpose;
	int32_t                                 numposes;
	float                           interval;
	trivertx_t                      bboxmin;
	trivertx_t                      bboxmax;
	int32_t                                 frame;
	char                            name[16];
} maliasframedesc_t;

typedef struct
{
	trivertx_t                      bboxmin;
	trivertx_t                      bboxmax;
	int32_t                                 frame;
} maliasgroupframedesc_t;

typedef struct
{
	int32_t                                         numframes;
	int32_t                                         intervals;
	maliasgroupframedesc_t  frames[1];
} maliasgroup_t;

// !!! if this is changed, it must be changed in asm_draw.h too !!!
typedef struct mtriangle_s
{
	int32_t                                 facesfront;
	int32_t                                 vertindex[3];
} mtriangle_t;


#define MAX_SKINS       32
typedef struct
{
	int32_t                 ident;
	int32_t                 version;
	vec3_t          scale;
	vec3_t          scale_origin;
	float           boundingradius;
	vec3_t          eyeposition;
	int32_t                 numskins;
	int32_t                 skinwidth;
	int32_t                 skinheight;
	int32_t                 numverts;
	int32_t                 numtris;
	int32_t                 numframes;
	synctype_t      synctype;
	int32_t                 flags;
	float           size;

	//ericw -- used to populate vbo
	int32_t                 numverts_vbo;   // number of verts with unique x,y,z,s,t
	intptr_t                meshdesc;       // offset into extradata: numverts_vbo aliasmesh_t
	int32_t                 numindexes;
	intptr_t                indexes;        // offset into extradata: numindexes unsigned shorts
	intptr_t                vertexes;       // offset into extradata: numposes*vertsperframe trivertx_t
	//ericw --

	int32_t                                 numposes;
	int32_t                                 poseverts;
	int32_t                                 posedata;       // numposes*poseverts trivert_t
	int32_t                                 commands;       // gl command list with embedded s/t
	struct gltexture_s      *gltextures[MAX_SKINS][4]; //johnfitz
	struct gltexture_s      *fbtextures[MAX_SKINS][4]; //johnfitz
	int32_t                                 texels[MAX_SKINS];      // only for player skins
	maliasframedesc_t       frames[1];      // variable sized
} aliashdr_t;

#define MAXALIASVERTS   2000 //johnfitz -- was 1024
#define MAXALIASFRAMES  256
#define MAXALIASTRIS    2048
extern  aliashdr_t      *pheader;
extern  stvert_t        stverts[MAXALIASVERTS];
extern  mtriangle_t     triangles[MAXALIASTRIS];
extern  trivertx_t      *poseverts[MAXALIASFRAMES];

//===================================================================

//
// Whole model
//

typedef enum {mod_brush, mod_sprite, mod_alias} modtype_t;

#define EF_ROCKET       1                       // leave a trail
#define EF_GRENADE      2                       // leave a trail
#define EF_GIB          4                       // leave a trail
#define EF_ROTATE       8                       // rotate (bonus items)
#define EF_TRACER       16                      // green split trail
#define EF_ZOMGIB       32                      // small blood trail
#define EF_TRACER2      64                      // orange split trail + rotate
#define EF_TRACER3      128                     // purple trail
#define MF_HOLEY        (1u<<14)                // MarkV/QSS -- make index 255 transparent on mdl's

//johnfitz -- extra flags for rendering
#define MOD_NOLERP              256             //don't lerp when animating
#define MOD_NOSHADOW    512             //don't cast a shadow
#define MOD_FBRIGHTHACK 1024    //when fullbrights are disabled, use a hack to render this model brighter
//johnfitz

typedef struct qmodel_s
{
	char            name[MAX_QPATH];
	uint32_t        path_id;                // path id of the game directory
	// that this model came from
	bool    needload;               // bmodels and sprites don't cache normally

	modtype_t       type;
	int32_t                 numframes;
	synctype_t      synctype;

	int32_t                 flags;

//
// volume occupied by the model graphics
//
	vec3_t          mins, maxs;
	vec3_t          ymins, ymaxs; //johnfitz -- bounds for entities with nonzero yaw
	vec3_t          rmins, rmaxs; //johnfitz -- bounds for entities with nonzero pitch or roll
	//johnfitz -- removed float radius;

//
// solid volume for clipping
//
	bool    clipbox;
	vec3_t          clipmins, clipmaxs;

//
// brush model
//
	int32_t                 firstmodelsurface, nummodelsurfaces;

	int32_t                 numsubmodels;
	dmodel_t        *submodels;

	int32_t                 numplanes;
	mplane_t        *planes;

	int32_t                 numleafs;               // number of visible leafs, not counting 0
	mleaf_t         *leafs;

	int32_t                 numvertexes;
	mvertex_t       *vertexes;

	int32_t                 numedges;
	medge_t         *edges;

	int32_t                 numnodes;
	mnode_t         *nodes;

	int32_t                 numtexinfo;
	mtexinfo_t      *texinfo;

	int32_t                 numsurfaces;
	msurface_t      *surfaces;

	int32_t                 numsurfedges;
	int32_t                 *surfedges;

	int32_t                 numclipnodes;
	mclipnode_t     *clipnodes; //johnfitz -- was dclipnode_t

	int32_t                 nummarksurfaces;
	msurface_t      **marksurfaces;

	hull_t          hulls[MAX_MAP_HULLS];

	int32_t                 numtextures;
	texture_t       **textures;

	byte            *visdata;
	byte            *lightdata;
	char            *entities;

	bool    viswarn; // for Mod_DecompressVis()

	int32_t                 bspversion;

//
// alias model
//

	GLuint          meshvbo;
	GLuint          meshindexesvbo;
	int32_t                 vboindexofs;    // offset in vbo of the hdr->numindexes unsigned shorts
	int32_t                 vboxyzofs;      // offset in vbo of hdr->numposes*hdr->numverts_vbo meshxyz_t
	int32_t                 vbostofs;       // offset in vbo of hdr->numverts_vbo meshst_t

//
// additional model data
//
	cache_user_t    cache;          // only access through Mod_Extradata

} qmodel_t;

//============================================================================

void    Mod_Init(void);
void    Mod_ClearAll(void);
void    Mod_ResetAll(void);  // for gamedir changes (Host_Game_f)
qmodel_t *Mod_ForName(const char *name, bool crash);
void    *Mod_Extradata(qmodel_t *mod);  // handles caching
void    Mod_TouchModel(const char *name);

mleaf_t *Mod_PointInLeaf(float *p, qmodel_t *model);
byte    *Mod_LeafPVS(mleaf_t *leaf, qmodel_t *model);
byte    *Mod_NoVisPVS(qmodel_t *model);

void Mod_SetExtraFlags(qmodel_t *mod);

#endif  // __MODEL__