//-----------------------------------------------------------------------------
//
//  $Logfile:: /Source/gl_model.h                                             $
// $Revision:: 3                                                              $
//   $Author:: Burgermac                                                      $
//     $Date:: 6/8/01 11:04 AM                                                $
//
// Copyright (C) 1998 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// DESCRIPTION:
// d*_t structures are on-disk representations
// m*_t structures are in-memory
//

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

BRUSH MODELS

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

#ifndef __GL_MODEL_H__
#define __GL_MODEL_H__

#ifndef __QFILES_H__
#include "qfiles.h"
#endif

#ifndef __GL_LOC1_H__
#include "gl_loc1.h"
#endif

#ifdef __cplusplus
extern "C" {
#endif

//
// in memory representation
//
// !!! if this is changed, it must be changed in asm_draw.h too !!!

#define	SIDE_FRONT	0
#define	SIDE_BACK	1
#define	SIDE_ON		2
#define	SURF_PLANEBACK		2
#define	SURF_DRAWSKY		4
#define SURF_DRAWTURB		0x10
#define SURF_DRAWBACKGROUND	0x40
#define SURF_UNDERWATER		0x80
#define SURF_DRAWNONLIT		0x100
#define SURF_DRAWMASKED		0x200


typedef struct {
	vec3_t		position;
} mvertex_t;

typedef struct {
	unsigned short	v[2];
	unsigned int	cachededgeoffset;
} medge_t;

typedef struct {
	vec3_t		mins, maxs;
	vec3_t		origin;		// for sounds or lights
	float		radius;
	int			headnode;
	int			visleafs;		// not including the solid leaf 0
	int			firstface, numfaces;
} mmodel_t;

// !!! if this is changed, it must be changed in asm_draw.h too !!!

typedef struct mtexinfo_s {
	float		         vecs[2][4];
	int			      flags;
	struct mtexinfo_s	*next;		// animation chain
	image_t		      *image;
	csurface_t        *surf;
} mtexinfo_t;

#define	VERTEXSIZE	7

typedef struct glpoly_s
{
	struct	glpoly_s	*next;
	struct	glpoly_s	*chain;
	int		numverts;
	int		flags;			// for SURF_UNDERWATER (not needed anymore?)
	float	verts[4][VERTEXSIZE];	// variable sized (xyz s1t1 s2t2)
} glpoly_t;

#define MAX_SPLATTER_VERTS 6
typedef struct splatter_s {
	int		numverts;
	float	verts[MAX_SPLATTER_VERTS][VERTEXSIZE];	// variable sized (xyz s1t1 s2t2)
	struct	splatter_s * next;
} splatter_t;

typedef struct msurface_s {
	int			visframe;		// should be drawn when node is crossed

	cplane_t	*plane;
	int			flags;

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

	short		texturemins[2];
	short		extents[2];

	int			light_s, light_t;	// gl lightmap coordinates
#ifdef _H2INC
	int         dlight_s, AMD_dlight_t; // gl lightmap coordinates for dynamic lightmaps
#else
	int			dlight_s, dlight_t; // gl lightmap coordinates for dynamic lightmaps
#endif

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

	mtexinfo_t	*texinfo;
// lighting info
	int			dlightframe;
	int			dlightbits;
	qboolean	cached_dlight;	/* Knightmare */

	int			lightmaptexturenum;
#ifdef _H2INC
	unsigned char styles[MAXLIGHTMAPS];
#else
	byte		styles[MAXLIGHTMAPS];
	#endif
	int			cached_light[MAXLIGHTMAPS];	// values currently used in lightmap
#ifdef _H2INC
	unsigned char *samples;      // [numstyles*surfsize]
#else
	byte     *samples;      // [numstyles*surfsize]
#endif
	entity_t *owner;
	mtexinfo_t *first_texinfo;
	splatter_t *splatter_surface;
} msurface_t;

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

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

	struct mnode_s	*parent;

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

	unsigned short		firstsurface;
	unsigned short		numsurfaces;
} mnode_t;

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

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

	struct mnode_s	*parent;

// leaf specific
	int			cluster;
	int			area;

	msurface_t	**firstmarksurface;
	int			nummarksurfaces;
} mleaf_t;

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

//
// Whole model
//

typedef enum {mod_bad, mod_brush, mod_sprite, mod_alias, mod_sinmdl } modtype_t;

typedef struct model_t
{
#ifdef _H2INC
	char     AMD_name[MAX_QPATH];
#else
	char		name[MAX_QPATH];
#endif

	int			registration_sequence;

#ifdef _H2INC
	modtype_t   AMD_type;
#else
	modtype_t   type;
#endif
	int			numframes;
	int			flags;

//
// volume occupied by the model graphics
//
	vec3_t		mins, maxs;
	float		radius;

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

//
// brush model
//
	int			firstmodelsurface, nummodelsurfaces;
	int			lightmap;		// only for submodels

	int			numsubmodels;
	mmodel_t	*submodels;

	int			numplanes;
	cplane_t	*planes;

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

	int			numvertexes;
	mvertex_t	*vertexes;

	int			numedges;
	medge_t		*edges;

	int			numnodes;
	int			firstnode;
	mnode_t		*nodes;

	int			numtexinfo;
	mtexinfo_t	*texinfo;

	int			numsurfaces;
	msurface_t	*surfaces;

	int			numsurfedges;
	int			*surfedges;

	int			nummarksurfaces;
	msurface_t	**marksurfaces;

	dvis_t		*vis;

	byte *lightdata;

	// for alias models and skins
	image_t		*skins[MAX_MD2SKINS];

	int			extradatasize;
	void		*extradata;
} model_t;

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

extern mleaf_t *Mod_PointInLeaf (float *p, model_t *model);
extern byte *Mod_ClusterPVS (int cluster, model_t *model);
void Mod_Modellist_f (void);
void Mod_Init (void);
model_t *Mod_ForName (const char *name, qboolean crash);
void Mod_LoadBrushModel (model_t *mod, void *buffer);
void Mod_LoadAliasModel (model_t *mod, void *buffer);
void Mod_LoadSpriteModel (model_t *mod, void *buffer);
void	R_BeginRegistration (const char *map, csurface_t *surfaces);
struct model_t	*R_RegisterModel (const char *name);
void	R_EndRegistration (void);
void Mod_Free (model_t *mod);
void Mod_FreeAll (void);
int R_GetNumFrames( entity_t * ent );

void Mod_ClearAll (void);
#ifndef _H2INC

void *Hunk_Begin (int maxsize);
void *Hunk_Alloc (int size);
int Hunk_End(void);
void Hunk_Free(void *base);
#endif


#ifdef __cplusplus
}
#endif

#endif
