fteqw/engine/gl/gl_terrain.h

#ifdef TERRAIN

//#define STRICTEDGES	//strict (ugly) grid
#define TERRAINTHICKNESS 16
#define TERRAINACTIVESECTIONS 3000

/*
a note on networking:
By default terrain is NOT networked. This means content is loaded without networking delays.
If you wish to edit the terrain collaboratively, you can enable the mod_terrain_networked cvar.
When set, changes on the server will notify clients that a section has changed, and the client will reload it as needed.
Changes on the client WILL NOT notify the server, and will get clobbered if the change is also made on the server.
This means for editing purposes, you MUST funnel it via ssqc with your own permission checks.
It also means for explosions and local stuff, the server will merely restate changes from impacts if you do them early. BUT DO NOT CALL THE EDIT FUNCTION IF THE SERVER HAS ALREADY APPLIED THE CHANGE.
*/
/*
terminology:
tile:
	a single grid tile of 2*2 height samples.
	iterrated for collisions but otherwise unused.
section:
	16*16 tiles, with a single texture spread over them.
	samples have an overlap with the neighbouring section (so 17*17 height samples). texture samples do not quite match height frequency (63*63 vs 16*16).
	smallest unit for culling.
block:
	16*16 sections. forms a single disk file. used only to avoid 16777216 files in a single directory, instead getting 65536 files for a single fully populated map... much smaller...
	each block file is about 4mb each. larger can be detrimental to automatic downloads.
cluster:
	64*64 sections
	internal concept to avoid a single pointer array of 16 million entries per terrain.
*/

int Surf_NewLightmaps(int count, int width, int height, uploadfmt_t fmt, qboolean deluxe);

#define MAXCLUSTERS 64
#define MAXSECTIONS 64	//this many sections within each cluster in each direction
#define SECTHEIGHTSIZE 17 //this many height samples per section (one for overlap)
#define SECTTEXSIZE 64	//this many texture samples per section (one for overlap, yes, this is a little awkward)
#define SECTIONSPERBLOCK 16

//each section is this many sections higher in world space, to keep the middle centered at '0 0'
#define CHUNKBIAS	(MAXCLUSTERS*MAXSECTIONS/2)
#define CHUNKLIMIT	(MAXCLUSTERS*MAXSECTIONS)

#define LMCHUNKS 8//(LMBLOCK_WIDTH/SECTTEXSIZE)	//FIXME: make dynamic.
#define HMLMSTRIDE (LMCHUNKS*SECTTEXSIZE)

#define SECTION_MAGIC (*(int*)"HMMS")
#define SECTION_VER_DEFAULT	1
/*simple version history:
ver=0
	SECTHEIGHTSIZE=16
ver=1
	SECTHEIGHTSIZE=17 (oops, makes holes more usable)
	(holes in this format are no longer supported)
ver=2
	uses deltas instead of absolute values
	variable length image names
*/

#define TGS_NOLOAD			0
#define TGS_LAZYLOAD		1	//see if its available, if not, queue it. don't create too much work at once. peace man
#define TGS_TRYLOAD			2	//try and get it, but don't stress if its not available yet
#define TGS_WAITLOAD		4	//load it, wait for it if needed.
#define TGS_ANYSTATE		8	//returns the section regardless of its current state, even if its loading.
#define TGS_NODOWNLOAD		16	//don't queue it for download
#define TGS_NORENDER		32	//don't upload any textures or whatever
#define TGS_DEFAULTONFAIL	64	//if it failed to load, generate a default anyway

enum
{
	//these flags can be found on disk
	TSF_HASWATER_V0	= 1u<<0,	//no longer flagged.
	TSF_HASCOLOURS	= 1u<<1,
	TSF_HASHEIGHTS	= 1u<<2,
	TSF_HASSHADOW	= 1u<<3,

	//these flags are found only on disk
	TSF_D_UNUSED1	= 1u<<28,
	TSF_D_UNUSED2	= 1u<<29,
	TSF_D_UNUSED3	= 1u<<30,
	TSF_D_UNUSED4	= 1u<<31,

	//these flags should not be found on disk
	TSF_NOTIFY		= 1u<<28,	//modified on server, waiting for clients to be told about the change.
	TSF_RELIGHT		= 1u<<29,	//height edited, needs relighting.
	TSF_DIRTY		= 1u<<30,	//its heightmap has changed, the mesh needs rebuilding
	TSF_EDITED		= 1u<<31	//says it needs to be written if saved

#define TSF_INTERNAL	(TSF_RELIGHT|TSF_DIRTY|TSF_EDITED|TSF_NOTIFY)
};
enum
{
	TMF_SCALE	= 1u<<0,
	//what else do we want? alpha? colormod perhaps?
};

typedef struct
{
	int size;
	vec3_t axisorg[4];
	float scale;
	int reserved3;
	int reserved2;
	int reserved1;
	//char modelname[1+];
} dsmesh_v1_t;

typedef struct
{
	unsigned int flags;
	char texname[4][32];
	unsigned int texmap[SECTTEXSIZE][SECTTEXSIZE];
	float heights[SECTHEIGHTSIZE*SECTHEIGHTSIZE];
	unsigned short holes;
	unsigned short reserved0;
	float waterheight;
	float minh;
	float maxh;
	int ents_num;
	int reserved1;
	int reserved4;
	int reserved3;
	int reserved2;
} dsection_v1_t;

//file header for a single section
typedef struct
{
	int magic;
	int ver;
} dsection_t;

//file header for a block of sections.
//(because 16777216 files in a single directory is a bad plan. windows really doesn't like it.)
typedef struct
{
	//a block is a X*Y group of sections
	//if offset==0, the section isn't present.
	//the data length of the section preceeds the actual data.
	int magic;
	int ver;
	unsigned int offset[SECTIONSPERBLOCK*SECTIONSPERBLOCK];
} dblock_t;

typedef struct hmpolyset_s
{
	struct hmpolyset_s *next;
	shader_t *shader;
	mesh_t mesh;
	mesh_t *amesh;
	vbo_t vbo;
} hmpolyset_t;
struct hmwater_s
{
	struct hmwater_s *next;
	unsigned int contentmask;
	qboolean simple;	//no holes, one height
	float minheight;
	float maxheight;
	char shadername[MAX_QPATH];
	shader_t *shader;
	qbyte holes[8];
	float heights[9*9];

/*
	qboolean facesdown;
	unsigned int contentmask;
	float		heights[SECTHEIGHTSIZE*SECTHEIGHTSIZE];
#ifndef SERVERONLY
	byte_vec4_t	colours[SECTHEIGHTSIZE*SECTHEIGHTSIZE];
	char texname[4][MAX_QPATH];
	int lightmap;
	int lmx, lmy;

	texnums_t textures;
	vbo_t vbo;
	mesh_t mesh;
	mesh_t *amesh;
#endif
*/
};
enum
{
	TSLS_NOTLOADED,
	TSLS_LOADING0,	//posted to a worker, but not picked up yet. this allows a single worker to generate multiple sections without fighting.
	TSLS_LOADING1,	//section is queued to the worker (and may be loaded as part of another section)
	TSLS_LOADING2,	//waiting for main thread to finish, worker will ignore
	TSLS_LOADED,
	TSLS_FAILED
};
typedef struct
{
	link_t recycle;
	int sx, sy;

	int loadstate;
	float timestamp;	//don't recycle it if its still fairly recent.

	float heights[SECTHEIGHTSIZE*SECTHEIGHTSIZE];
	unsigned char holes[8];
	unsigned int flags;
	float maxh_cull;	//includes water+mesh heights
	float minh, maxh;
	struct heightmap_s *hmmod;

	//FIXME: make layers, each with their own holes+heights+contents+textures+shader+mixes. water will presumably have specific values set for each part.
	struct hmwater_s *water;

	size_t traceseq;

#ifndef SERVERONLY
	pvscache_t pvscache;
	vec4_t colours[SECTHEIGHTSIZE*SECTHEIGHTSIZE];	//FIXME: make bytes
	char texname[4][MAX_QPATH];	//fixme: make path length dynamic.
	int lightmap;
	int lmx, lmy;

	texnums_t textures;
	vbo_t vbo;
	mesh_t mesh;
	mesh_t *amesh;

	hmpolyset_t *polys;
#endif
	int numents;
	int maxents;
	struct hmentity_s **ents;
} hmsection_t;
typedef struct
{
	hmsection_t *section[MAXSECTIONS*MAXSECTIONS];
} hmcluster_t;

#ifndef SERVERONLY
typedef struct brushbatch_s
{
	vbo_t vbo;
	mesh_t mesh;
	mesh_t *pmesh;
	int lightmap;
	struct brushbatch_s *next;
	avec4_t align;	//meh, cos we can.
} brushbatch_t;
#endif
typedef struct brushtex_s
{
	char shadername[MAX_QPATH];
#ifndef SERVERONLY
	shader_t *shader;

	//for rebuild performance
	int firstlm;
	int lmcount;

	struct brushbatch_s *batches;
#endif
	qboolean rebuild;
	struct brushtex_s *next;
} brushtex_t;

typedef struct patchtessvert_s
{
	vec3_t v;
	vec4_t rgba;
	vec2_t tc;
//	vec3_t norm;
//	vec3_t sdir;
//	vec3_t tdir;
} patchtessvert_t;
typedef struct qcpatchvert_s
{
	vec3_t v;
	vec4_t rgba;
	vec2_t tc;
} qcpatchvert_t;
patchtessvert_t *PatchInfo_Evaluate(const qcpatchvert_t *cp, const unsigned short patch_cp[2], const short subdiv[2], unsigned short *size);
unsigned int PatchInfo_EvaluateIndexes(const unsigned short *size, index_t *out_indexes);

typedef struct
{
	unsigned int	contents;	//bitmask
	unsigned int	id;			//networked/gamecode id.
	unsigned int	axialplanes;	//+x,+y,+z,-x,-y,-z. used for bevel stuff.
	unsigned int	numplanes;
	unsigned char	selected:1;	//different shader stuff
	unsigned char	ispatch:1;	//just for parsing really
	vec4_t			*planes;
	vec3_t			mins, maxs;	//for optimisation and stuff
	struct patchdata_s
	{	//unlit, always...
		brushtex_t *tex;
		unsigned short numcp[2];
		short subdiv[2];	//<0=regular q3 patch, 0=cp-only, >0=fixed-tessellation.

		unsigned short tesssize[2];
		patchtessvert_t *tessvert; //x+(y*tesssize[0])

		//control points
		qcpatchvert_t cp[1]; //x+(y*numcp[0]) extends past end of patchdata_s
	} *patch;	//if this is NULL, then its a regular brush. otherwise its a patch.
	struct brushface_s
	{
		brushtex_t *tex;
		vec4_t stdir[2];
		vec3_t *points;
		unsigned short numpoints;
		unsigned short lmscale;
		int	lightmap;
		unsigned short lmbase[2];	//min st coord of the lightmap atlas, in texels.
		unsigned short relight:1;
		unsigned short relit:1;
		int lmbias[2];
		unsigned short lmextents[2];
		unsigned int surfaceflags;	//used by q2
		unsigned int surfacevalue;	//used by q2 (generally light levels)
		qbyte *lightdata;
	} *faces;
} brushes_t;

typedef struct
{
	string_t	shadername;
	vec3_t		planenormal;
	float		planedist;
	vec3_t		sdir;
	float		sbias;
	vec3_t		tdir;
	float		tbias;
} qcbrushface_t;
typedef struct
{
	string_t	shadername;
	unsigned int contents;
	unsigned int cp_width;
	unsigned int cp_height;
	unsigned int subdiv_x;
	unsigned int subdiv_y;
	vec3_t		texinfo;
} qcpatchinfo_t;

typedef struct heightmap_s
{
	char path[MAX_QPATH];
	char skyname[MAX_QPATH];			//name of the skybox
	char groundshadername[MAX_QPATH];	//this is the shader we're using to draw the terrain itself. you could use other shaders here, for eg debugging or stylised weirdness.
	unsigned int culldistance;			//entities will be culled if they're this far away (squared distance
	float	maxdrawdist;				//maximum view distance. extends view if larger than fog implies.

	unsigned char *seed;				//used by whatever terrain generator.
	qboolean forcedefault;				//sections that cannot be loaded/generated will receive default values for stuff.
	char defaultgroundtexture[MAX_QPATH];//texture used for defaulted sections
	char defaultwatershader[MAX_QPATH];	//shader used for defaulted sections that have heights beneath defaultwaterheight.
	float defaultwaterheight;			//water height. if you want your islands to be surrounded by water.
	float defaultgroundheight;			//defaulted sections will have a z plane this high

	int firstsegx, firstsegy; //min bounds of the terrain, in sections
	int maxsegx, maxsegy; //max bounds of the terrain, in sections
	float sectionsize;	//each section is this big, in world coords
	hmcluster_t *cluster[MAXCLUSTERS*MAXCLUSTERS];
	shader_t *skyshader;
	shader_t *shader;
	mesh_t skymesh;
	mesh_t *askymesh;
	qboolean	legacyterrain;	//forced exterior=SOLID
	unsigned int exteriorcontents;	//contents type outside of the terrain sections area (.map should be empty, while terrain will usually block).
	unsigned int loadingsections;	//number of sections currently being loaded. avoid loading extras while non-zero.
	size_t traceseq;
	size_t drawnframe;
	enum
	{
		DGT_SOLID,	//invalid/new areas should be completely solid until painted.
		DGT_HOLES,	//invalid/new sections should be non-solid+invisible
		DGT_FLAT	//invalid/new sections should be filled with ground by default
	} defaultgroundtype;
	enum
	{
		HMM_TERRAIN,
		HMM_BLOCKS
	} mode;
	int tilecount[2];
	int tilepixcount[2];

	int activesections;
	link_t recycle;		//section list in lru order
//	link_t collected;	//memory that may be reused, to avoid excess reallocs.

	struct hmentity_s
	{
		size_t drawnframe;	//don't add it to the scene multiple times.
		size_t traceseq;	//don't trace through this entity multiple times if its in different sections.
		int refs;		//entity is free/reusable when its no longer referenced by any sections
		entity_t ent;	//note: only model+modelmatrix info is relevant. fixme: implement instancing.

		struct hmentity_s *next;	//used for freeing/allocating an entity
	} *entities;
	void *entitylock;	//lock this if you're going to read/write entities of any kind.

#ifndef SERVERONLY
	unsigned int numusedlmsects;	//to track leaks and stats
	unsigned int numunusedlmsects;
	struct lmsect_s
	{
		struct lmsect_s *next;
		int lm, x, y;
	} *unusedlmsects;
#endif

#ifndef SERVERONLY
	//I'm putting this here because we might have some quite expensive lighting routines going on
	//and that'll make editing the terrain jerky as fook, so relighting it a few texels at a time will help maintain a framerate while editing
	hmsection_t *relight;
	unsigned int relightidx;
	vec2_t relightmin;
#endif


	
	char *texmask;	//for editing - visually masks off the areas which CANNOT accept this texture
	qboolean entsdirty;	//ents were edited, so we need to reload all lighting...
	struct relight_ctx_s *relightcontext;
	struct llightinfo_s *lightthreadmem;
	qboolean inheritedlightthreadmem;
	qboolean recalculatebrushlighting;
	lmalloc_t brushlmalloc;
	float brushlmscale;
	unsigned int *brushlmremaps;
	unsigned int brushmaxlms;
	brushtex_t *brushtextures;
	brushes_t *wbrushes;
	unsigned int numbrushes;
	unsigned int brushidseq;
	qboolean brushesedited;
} heightmap_t;

typedef struct plugterrainfuncs_s
{
	void			*(QDECL *GenerateWater)			(hmsection_t *s, float maxheight);
	qboolean		 (QDECL *InitLightmap)			(hmsection_t *s, qboolean initialise);
	unsigned char	*(QDECL *GetLightmap)			(hmsection_t *s, int idx, qboolean edit);
	void			 (QDECL *AddMesh)				(heightmap_t *hm, int loadflags, model_t *mod, const char *modelname, vec3_t epos, vec3_t axis[3], float scale);
	hmsection_t		*(QDECL *GetSection)			(heightmap_t *hm, int x, int y, unsigned int flags);
	int				 (QDECL *GenerateSections)		(heightmap_t *hm, int sx, int sy, int count, hmsection_t **sects);
	void			 (QDECL *FinishedSection)		(hmsection_t *s, qboolean success);

	qboolean		 (QDECL *AutogenerateSection)(heightmap_t *hm, int sx, int sy, unsigned int tgsflags);	//replace this if you want to make a terrain generator.
#define plugterrainfuncs_name "Terrain"
} plugterrainfuncs_t;
#endif