eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity
fteqw/plugins/hl2/mod_vbsp.c

4212 lines
112 KiB
C
Raw Blame History

/*
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.
*/
/*
TODO:
Lightmaps - skip ssbump stuff properly. currently extra lightstyles are screwed.
Ent Lighting - leafs have some list of light 'cubes' that define lighting, allowing for ents to get backlit etc properly.
Areaportals - the server 'needs' a way to specify areaportals on a per-player basis. for now the gamecode will have to explicitly force-open most of the portals in the game (map_noareas can be used as a workaround).
Static Props - these are solid, but use the visible mesh for collisions instead of the special/simpler collision mesh. This makes it a bit easier to climb up them, which may be a gameplay issue.
Detail Props - we don't attempt to handle these. They need manual batching or something (eg clutter-shader stuff). Their loss should not affect gameplay much as they can be disabled in HL2 too.
Dynamic Lighting - r_dynamic not enabled.
Realtime Lighting - screwed. Doesn't light all world surfaces for some reason.
RBE(Bullet) - probably screwed.
Skyboxes - doesn't handle the whole per-face skies nor weird hdr encoding.
Fog - no fog here... this results in issues where the pvs provides distance culling.
Load Times - materials are loaded on a single thread. this gets slow.
Materials - all kinds of screwed.
Portal2 Gels - we need to repurpose stainmap code or something.
Refraction - this stuff is horribly expensive.
*/
#include "../plugin.h"
#include "quakedef.h"
#ifdef HAVE_CLIENT
#include "glquake.h"
#endif
#include "com_mesh.h"
#include "com_bih.h"
static plugfsfuncs_t *filefuncs;
static plugmodfuncs_t *modfuncs;
static plugthreadfuncs_t *threadfuncs;
#define Q_strncpyz Q_strlcpy
float VectorNormalize2(const vec3_t in,vec3_t out) {float l = sqrt(DotProduct(in,in)); if (l) l = 1.0/l; VectorScale(in,l,out); return l;}
#define VectorNormalize(v) VectorNormalize2(v,v)
fte_inlinebody float M_LinearToSRGB(float x, float mag);
vec3_t vec3_origin;
static refdef_t *refdef;
static vec3_t modelorg;
static qbyte *frustumvis;
static int vbsp_nodesequence; //to track which nodes need walking
static int vbsp_surfsequence; //so we don't draw the same surface if its found multiple ways
r_qrenderer_t qrenderer = QR_OPENGL;
#define MAX_VBSP_AREAS MAX_Q2MAP_AREAS
#define SURF_OFFNODE SURF_DRAWBACKGROUND //might as well just reuse that.
static cvar_t *hl2_novis;
static cvar_t *hl2_displacement_scale;
static cvar_t *hl2_favour_ldr;
static cvar_t *map_noareas;
static cvar_t *map_autoopenportals;
static cvar_t *hl2_contents_remap;
char *Q_strlwr(char *s)
{
char *ret=s;
while(*s)
{
if (*s >= 'A' && *s <= 'Z')
*s=*s-'A'+'a';
s++;
}
return ret;
}
void AddPointToBounds (const vec3_t v, vec3_t mins, vec3_t maxs)
{
int i;
vec_t val;
for (i=0 ; i<3 ; i++)
{
val = v[i];
if (val < mins[i])
mins[i] = val;
if (val > maxs[i])
maxs[i] = val;
}
}
void ClearBounds (vec3_t mins, vec3_t maxs)
{
mins[0] = mins[1] = mins[2] = FLT_MAX;
maxs[0] = maxs[1] = maxs[2] = -FLT_MAX;
}
/*
==================
BoxOnPlaneSide
Returns 1, 2, or 1 + 2
==================
*/
int VARGS BoxOnPlaneSide (const vec3_t emins, const vec3_t emaxs, const mplane_t *p)
{
float dist1, dist2;
int sides;
// general case
switch (p->signbits)
{
default:
case 0:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
break;
case 1:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
break;
case 2:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
break;
case 3:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
break;
case 4:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
break;
case 5:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
break;
case 6:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
break;
case 7:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
break;
}
sides = 0;
if (dist1 >= p->dist)
sides = 1;
if (dist2 < p->dist)
sides |= 2;
return sides;
}
#define Host_Error Sys_Errorf
enum hllumps_e
{ //note how this order matches q1 so well...
//and yet the format is disturbingly similar to q2... huh... :P
VLUMP_ENTITIES = LUMP_ENTITIES,
VLUMP_PLANES = LUMP_PLANES,
VLUMP_TEXTURES = LUMP_TEXTURES,
VLUMP_VERTEXES = LUMP_VERTEXES,
VLUMP_VISIBILITY = LUMP_VISIBILITY,
VLUMP_NODES = LUMP_NODES,
VLUMP_TEXINFO = LUMP_TEXINFO,
VLUMP_FACES_LDR = LUMP_FACES,
VLUMP_LIGHTING_LDR = LUMP_LIGHTING,
// VLUMP_FOO = 9,//LUMP_CLIPNODES
VLUMP_LEAFS = LUMP_LEAFS,
// VLUMP_FOO = 11,//LUMP_MARKSURFACES
VLUMP_EDGES = LUMP_EDGES,
VLUMP_SURFEDGES = LUMP_SURFEDGES,
VLUMP_MODELS = LUMP_MODELS,
// VLUMP_FOO = 15,
VLUMP_LEAFFACES = 16,
VLUMP_LEAFBRUSHES = 17,
VLUMP_BRUSHES = 18,
VLUMP_BRUSHSIDES = 19,
VLUMP_AREAS = 20,
VLUMP_AREAPORTALS = 21,
// VLUMP_FOO = 22,
// VLUMP_FOO = 23,
// VLUMP_FOO = 24,
// VLUMP_FOO = 25,
VLUMP_DISP_INFO = 26,
// VLUMP_FOO = 27,
// VLUMP_FOO = 28,
// VLUMP_FOO = 29,
// VLUMP_FOO = 30,
// VLUMP_FOO = 31,
VLUMP_DISP_LMALPHA = 32,
VLUMP_DISP_VERTS = 33,
VLUMP_DISP_LMCOORDS = 34,
VLUMP_GAMELUMP = 35,
// VLUMP_FOO = 36,
// VLUMP_FOO = 37,
// VLUMP_FOO = 38,
// VLUMP_FOO = 39,
VLUMP_ZIPFILE = 40,
VLUMP_AREAPORTALVERTS = 41,
// VLUMP_FOO = 42,
VLUMP_STRINGDATA = 43,
VLUMP_STRINGOFFSETS = 44,
// VLUMP_FOO = 45,
// VLUMP_FOO = 46,
// VLUMP_FOO = 47,
VLUMP_DISP_TRIFLAGS = 48,
// VLUMP_FOO = 49,
// VLUMP_FOO = 50,
VLUMP_LEAFLIGHTI_HDR= 51, //indexes into VLUMP_LEAFLIGHTV_HDR, two shorts per leaf.
VLUMP_LEAFLIGHTI_LDR= 52,
VLUMP_LIGHTING_HDR = 53,
// VLUMP_FOO = 54,
VLUMP_LEAFLIGHTV_HDR= 55,
VLUMP_LEAFLIGHTV_LDR= 56,
// VLUMP_FOO = 57,
VLUMP_FACES_HDR = 58,
// VLUMP_FOO = 59,
// VLUMP_FOO = 60,
// VLUMP_FOO = 61,
// VLUMP_FOO = 62,
// VLUMP_FOO = 63,
HL2_MAXLUMPS = 64
};
typedef struct {
unsigned int fileofs;
unsigned int filelen;
unsigned int foo[2];
} vlump_t;
typedef struct {
unsigned int magic;
unsigned int version;
vlump_t lumps[HL2_MAXLUMPS];
} dvbspheader_t;
typedef struct
{
int numareaportals;
int firstareaportal;
} carea_t;
typedef struct
{
int floodnum; // if two areas have equal floodnums, they are connected
int floodvalid; // flags the area as having been visited (sequence numbers matching prv->floodvalid)
} careaflood_t;
typedef struct cmodel_s
{
vec3_t mins, maxs;
vec3_t origin; // for sounds or lights
mnode_t *headnode;
mleaf_t *headleaf;
int numsurfaces;
int firstsurface;
int firstbrush;
int num_brushes;
} cmodel_t;
typedef struct dispinfo_s
{
struct msurface_s *surf;
vec3_t aamin;
vec3_t aamax;
pvscache_t pvs; //which pvs clusters this displacement is visible in...
unsigned int contents;
unsigned int width;
unsigned int height;
vecV_t *xyz; //(width+1)*(height+1)
index_t *idx; //width*height*6;
size_t numindexes;
struct dispvert_s
{
vec3_t norm;
vec2_t st;
float alpha;
} *verts;
//unsigned short *flags;
q2csurface_t csurface; //collision info for q2 gamecode.
} dispinfo_t;
typedef struct vbspinfo_s
{
struct
{
qbyte *vis;
pvsbuffer_t visbuf;
int viewcluster[2];
} vcache;
int numbrushsides;
q2cbrushside_t *brushsides;
q2mapsurface_t *surfaces;
dispinfo_t **surfdisp;
int numleafbrushes;
q2cbrush_t **leafbrushes;
int numcmodels;
cmodel_t *cmodels;
int numbrushes;
q2cbrush_t *brushes;
int numvisibility;
q2dvis_t *vis;
qbyte *phscalced;
struct vbsptexinfo_s
{
vec4_t lmvecs[2];
} *texinfo;
int numareas;
int floodvalid;
careaflood_t areaflood[MAX_VBSP_AREAS];
//areas have a list of portals that open into other areas.
carea_t *areas; //indexes into q2areaportals for flooding
size_t numareaportals;
q2dareaportal_t *areaportals;
//and this is the state that is actually changed. booleans.
qbyte portalopen[MAX_Q2MAP_AREAPORTALS]; //memset will work if it's a qbyte, really it should be a qboolean
mplane_t **portalplane;
qbyte portalquerying[MAX_Q2MAP_AREAPORTALS];
mesh_t *portalpoly; //[numq2areaportals]
int *occlusionqueries; //[numq2areaportals]
struct mleaflight_s
{
struct leaflightpoint_s
{
vec3_t rgb[6];
qbyte x, y, z;
} *point;
int count;
} *leaflight;
size_t numdisplacements;
dispinfo_t *displacements;
size_t numstaticprops;
struct staticprop_s
{
float fademindist;
float fademaxdist;
qboolean solid;
struct bihtransform_s transform;
vec3_t lightorg;
entity_t ent;
} *staticprops;
unsigned int contentsremap[32];
int summed; //for the main thread to wait on.
} vbspinfo_t;
static q2mapsurface_t nullsurface;
static int VBSP_NumInlineModels (model_t *model);
static cmodel_t *VBSP_InlineModel (model_t *model, char *name);
static void VBSP_FinalizeBrush(q2cbrush_t *brush);
static void FloodAreaConnections (vbspinfo_t *prv);
/*
===============================================================================
MAP LOADING
===============================================================================
*/
static unsigned int VBSP_TranslateContentBits(vbspinfo_t *prv, unsigned int source)
{
unsigned int ret = 0;
if (source & 0x0000ffff)
{
if (source & 0x0000000f)
{
if (source & 0x00000001) ret |= prv->contentsremap[ 0];
if (source & 0x00000002) ret |= prv->contentsremap[ 1];
if (source & 0x00000004) ret |= prv->contentsremap[ 2];
if (source & 0x00000008) ret |= prv->contentsremap[ 3];
}
if (source & 0x000000f0)
{
if (source & 0x00000010) ret |= prv->contentsremap[ 4];
if (source & 0x00000020) ret |= prv->contentsremap[ 5];
if (source & 0x00000040) ret |= prv->contentsremap[ 6];
if (source & 0x00000080) ret |= prv->contentsremap[ 7];
}
if (source & 0x000000f00)
{
if (source & 0x00000100) ret |= prv->contentsremap[ 8];
if (source & 0x00000200) ret |= prv->contentsremap[ 9];
if (source & 0x00000400) ret |= prv->contentsremap[10];
if (source & 0x00000800) ret |= prv->contentsremap[11];
}
if (source & 0x000000f00)
{
if (source & 0x000001000) ret |= prv->contentsremap[12];
if (source & 0x000002000) ret |= prv->contentsremap[13];
if (source & 0x000004000) ret |= prv->contentsremap[14];
if (source & 0x000008000) ret |= prv->contentsremap[15];
}
}
if (source & 0xffff0000)
{
if (source & 0x000f0000)
{
if (source & 0x00010000) ret |= prv->contentsremap[16];
if (source & 0x00020000) ret |= prv->contentsremap[17];
if (source & 0x00040000) ret |= prv->contentsremap[18];
if (source & 0x00080000) ret |= prv->contentsremap[19];
}
if (source & 0x00f00000)
{
if (source & 0x00100000) ret |= prv->contentsremap[20];
if (source & 0x00200000) ret |= prv->contentsremap[21];
if (source & 0x00400000) ret |= prv->contentsremap[22];
if (source & 0x00800000) ret |= prv->contentsremap[23];
}
if (source & 0x0f000000)
{
if (source & 0x01000000) ret |= prv->contentsremap[24];
if (source & 0x02000000) ret |= prv->contentsremap[25];
if (source & 0x04000000) ret |= prv->contentsremap[26];
if (source & 0x08000000) ret |= prv->contentsremap[27];
}
if (source & 0xf0000000)
{
if (source & 0x10000000) ret |= prv->contentsremap[28];
if (source & 0x20000000) ret |= prv->contentsremap[29];
if (source & 0x40000000) ret |= prv->contentsremap[30];
if (source & 0x80000000) ret |= prv->contentsremap[31];
}
}
return ret;
}
static void VBSP_TranslateContentBits_Setup(vbspinfo_t *prv)
{
size_t i, j;
char contname[64];
const char *contremap = hl2_contents_remap->string;
static const struct {
const char *name;
unsigned int contents;
} knowncontents[] =
{
{"empty", FTECONTENTS_EMPTY},
{"solid", FTECONTENTS_SOLID},
{"window", FTECONTENTS_WINDOW},
{"lava", FTECONTENTS_LAVA},
{"slime", FTECONTENTS_SLIME},
{"water", FTECONTENTS_WATER},
{"ladder", FTECONTENTS_LADDER},
{"playerclip", FTECONTENTS_PLAYERCLIP},
{"monsterclip", FTECONTENTS_MONSTERCLIP},
{"clip", FTECONTENTS_PLAYERCLIP|FTECONTENTS_MONSTERCLIP},
{"body", FTECONTENTS_BODY},
{"corpse", FTECONTENTS_CORPSE},
{"detail", FTECONTENTS_DETAIL},
{"sky", FTECONTENTS_SKY},
{"Q2SOLID", Q2CONTENTS_SOLID},
{"Q2WINDOW", Q2CONTENTS_WINDOW},
{"Q2AUX", Q2CONTENTS_AUX},
{"Q2LAVA", Q2CONTENTS_LAVA},
{"Q2SLIME", Q2CONTENTS_SLIME},
{"Q2WATER", Q2CONTENTS_WATER},
{"Q2MIST", Q2CONTENTS_MIST},
{"Q2AREAPORTAL", Q2CONTENTS_AREAPORTAL},
{"Q2PLAYERCLIP", Q2CONTENTS_PLAYERCLIP},
{"Q2MONSTERCLIP", Q2CONTENTS_MONSTERCLIP},
{"Q2CURRENT_0", Q2CONTENTS_CURRENT_0},
{"Q2CURRENT_90", Q2CONTENTS_CURRENT_90},
{"Q2CURRENT_180", Q2CONTENTS_CURRENT_180},
{"Q2CURRENT_270", Q2CONTENTS_CURRENT_270},
{"Q2CURRENT_UP", Q2CONTENTS_CURRENT_UP},
{"Q2CURRENT_DOWN", Q2CONTENTS_CURRENT_DOWN},
{"Q2ORIGIN", Q2CONTENTS_ORIGIN},
{"Q2MONSTER", Q2CONTENTS_MONSTER},
{"Q2DEADMONSTER", Q2CONTENTS_DEADMONSTER},
{"Q2DETAIL", Q2CONTENTS_DETAIL},
{"Q2TRANSLUCENT", Q2CONTENTS_TRANSLUCENT},
{"Q2LADDER", Q2CONTENTS_LADDER},
{"Q3SOLID", Q3CONTENTS_SOLID},
{"Q3LAVA", Q3CONTENTS_LAVA},
{"Q3SLIME", Q3CONTENTS_SLIME},
{"Q3WATER", Q3CONTENTS_WATER},
{"Q3NOTTEAM1", Q3CONTENTS_NOTTEAM1},
{"Q3NOTTEAM2", Q3CONTENTS_NOTTEAM2},
{"Q3NOBOTCLIP", Q3CONTENTS_NOBOTCLIP},
{"Q3AREAPORTAL", Q3CONTENTS_AREAPORTAL},
{"Q3PLAYERCLIP", Q3CONTENTS_PLAYERCLIP},
{"Q3MONSTERCLIP", Q3CONTENTS_MONSTERCLIP},
{"Q3TELEPORTER", Q3CONTENTS_TELEPORTER},
{"Q3JUMPPAD", Q3CONTENTS_JUMPPAD},
{"Q3CLUSTERPORTAL", Q3CONTENTS_CLUSTERPORTAL},
{"Q3DONOTENTER", Q3CONTENTS_DONOTENTER},
{"Q3BOTCLIP", Q3CONTENTS_BOTCLIP},
{"Q3MOVER", Q3CONTENTS_MOVER},
{"Q3ORIGIN", Q3CONTENTS_ORIGIN},
{"Q3BODY", Q3CONTENTS_BODY},
{"Q3CORSE", Q3CONTENTS_CORPSE},
{"Q3DETAIL", Q3CONTENTS_DETAIL},
{"Q3STRUCTURAL", Q3CONTENTS_STRUCTURAL},
{"Q3TRANSLUCENT", Q3CONTENTS_TRANSLUCENT},
{"Q3TRIGGER", Q3CONTENTS_TRIGGER},
{"Q3NODROP", Q3CONTENTS_NODROP},
};
if (!*contremap)
for (i = 0; i < 32; i++)
prv->contentsremap[i] = 1<<i;
else for (i = 0; i < 32; i++)
{
contremap = cmdfuncs->ParseToken(contremap, contname, sizeof(contname), NULL);
if (!contremap || !*contname)
prv->contentsremap[i] = 0;
else
{
char *tmp;
int bit = strtol(contname, &tmp, 10);
if (!*tmp)
{
if (bit >= 0)
prv->contentsremap[i] = 1<<bit;
}
else
{
for (j = 0; j < countof(knowncontents); j++)
{
if (!Q_strcasecmp(contname, knowncontents[j].name))
{
prv->contentsremap[i] = knowncontents[j].contents;
break;
}
}
if (j == countof(knowncontents))
Con_Printf(CON_WARNING"%s: Unknown bit name %s\n", hl2_contents_remap->name, contname);
}
}
}
}
static void VBSP_SetParent (mnode_t *node, mnode_t *parent)
{
node->parent = parent;
if (node->contents != -1)
return;
VBSP_SetParent (node->children[0], node);
VBSP_SetParent (node->children[1], node);
}
static void VBSP_FindBrushRange (vbspinfo_t *prv, mnode_t *node, size_t *firstbrush, size_t *lastbrush)
{
size_t u, b;
mleaf_t *leaf;
while (node->contents == -1)
{ //walk every node to find every leaf...
VBSP_FindBrushRange(prv, node->children[0], firstbrush, lastbrush);
node = node->children[1];
}
leaf = (mleaf_t*)node;
for (u = 0; u < leaf->numleafbrushes; u++)
{
b = prv->leafbrushes[leaf->firstleafbrush+u]-prv->brushes;
if (*firstbrush > b)
*firstbrush = b;
if (*lastbrush < b+1)
*lastbrush = b+1;
}
}
static qboolean VBSP_LoadVertexes (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
dvertex_t *in;
mvertex_t *out;
size_t i, count;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "VBSP_LoadVertexes: funny lump size in %s\n", loadmodel->name);
return false;
}
out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));
loadmodel->vertexes = out;
loadmodel->numvertexes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->position[0] = LittleFloat (in->point[0]);
out->position[1] = LittleFloat (in->point[1]);
out->position[2] = LittleFloat (in->point[2]);
}
return true;
}
static qboolean VBSP_LoadEdges (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
medge_t *out;
size_t i, count;
dsedge_t *in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
{
Con_Printf ("VBSP_LoadEdges: funny lump size in %s\n", loadmodel->name);
return false;
}
out = plugfuncs->GMalloc(&loadmodel->memgroup, (count + 1) * sizeof(*out));
loadmodel->edges = out;
loadmodel->numedges = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->v[0] = (unsigned short)LittleShort(in->v[0]);
out->v[1] = (unsigned short)LittleShort(in->v[1]);
}
return true;
}
static qboolean VBSP_LoadSurfedges (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
size_t i, count;
unsigned int *in, *out;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
if (l->filelen % sizeof(*in) || count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "VBSP_LoadSurfedges: funny lump size in %s\n",loadmodel->name);
return false;
}
out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));
loadmodel->surfedges = out;
loadmodel->numsurfedges = count;
for ( i=0 ; i<count ; i++)
out[i] = LittleLong (in[i]);
return true;
}
static qboolean VBSP_LoadMarksurfaces (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
size_t i, j, count;
msurface_t **out;
unsigned short *ins;
ins = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*ins);
if (l->filelen % sizeof(*ins) || count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "VBSP_LoadMarksurfaces: funny lump size in %s\n",loadmodel->name);
return false;
}
out = plugfuncs->GMalloc(&loadmodel->memgroup, count*sizeof(*out));
loadmodel->marksurfaces = out;
loadmodel->nummarksurfaces = count;
for ( i=0 ; i<count ; i++)
{
j = (unsigned short)LittleShort(ins[i]);
if (j >= loadmodel->numsurfaces)
{
Con_Printf (CON_ERROR "VBSP_LoadMarksurfaces: bad surface number\n");
return false;
}
out[i] = loadmodel->surfaces + j;
}
return true;
}
static qboolean VBSP_LoadEntities (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
return modfuncs->LoadEntities(loadmodel, mod_base+l->fileofs, l->filelen);
}
/*
=================
CMod_LoadSubmodels
=================
*/
static qboolean VBSP_LoadSubmodels (model_t *loadmodel, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)loadmodel->meshinfo;
q2dmodel_t *in;
cmodel_t *out;
int i, j, count;
size_t firstbrush, lastbrush;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadSubmodels: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count < 1)
{
Con_Printf (CON_ERROR "Map with no models\n");
return false;
}
if (count > SANITY_MAX_Q2MAP_MODELS)
{
Con_Printf (CON_ERROR "Map has too many models\n");
return false;
}
out = prv->cmodels = plugfuncs->GMalloc(&loadmodel->memgroup, count * sizeof(*prv->cmodels));
prv->numcmodels = count;
for (i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<3 ; j++)
{ // spread the mins / maxs by a pixel
out->mins[j] = LittleFloat (in->mins[j]) - 1;
out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
out->origin[j] = LittleFloat (in->origin[j]);
}
out->headnode = loadmodel->nodes + LittleLong (in->headnode);
out->firstsurface = LittleLong (in->firstface);
out->numsurfaces = LittleLong (in->numfaces);
firstbrush = ~0u;
lastbrush = 0u;
VBSP_FindBrushRange(prv, out->headnode, &firstbrush, &lastbrush);
if (lastbrush > firstbrush)
{
out->firstbrush = firstbrush;
out->num_brushes = lastbrush-firstbrush;
}
}
AddPointToBounds(prv->cmodels[0].mins, loadmodel->mins, loadmodel->maxs);
AddPointToBounds(prv->cmodels[0].maxs, loadmodel->mins, loadmodel->maxs);
return true;
}
/*
=================
CMod_LoadBrushes
=================
*/
static qboolean VBSP_LoadBrushes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
q2dbrush_t *in;
q2cbrush_t *out;
int i, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadBrushes: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "Map has too many brushes");
return false;
}
prv->brushes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+1));
out = prv->brushes;
prv->numbrushes = count;
for (i=0 ; i<count ; i++, out++, in++)
{
//FIXME: missing bounds checks
out->brushside = &prv->brushsides[LittleLong(in->firstside)];
out->numsides = LittleLong(in->numsides);
out->contents = VBSP_TranslateContentBits(prv, LittleLong(in->contents));
VBSP_FinalizeBrush(out);
}
return true;
}
/*
=================
CMod_LoadPlanes
=================
*/
static qboolean VBSP_LoadPlanes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
int i, j;
mplane_t *out;
dplane_t *in;
int count;
int bits;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadPlanes: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count < 1)
{
Con_Printf (CON_ERROR "Map with no planes\n");
return false;
}
// need to save space for box planes
if (count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "Map has too many planes (%i)\n", count);
return false;
}
mod->planes = out = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
mod->numplanes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
bits = 0;
for (j=0 ; j<3 ; j++)
{
out->normal[j] = LittleFloat (in->normal[j]);
if (out->normal[j] < 0)
bits |= 1<<j;
}
out->dist = LittleFloat (in->dist);
out->type = LittleLong (in->type);
out->signbits = bits;
}
return true;
}
/*
=================
CMod_LoadLeafBrushes
=================
*/
static qboolean VBSP_LoadLeafBrushes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i;
q2cbrush_t **out;
unsigned short *in;
int count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadLeafBrushes: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count < 1)
{
Con_Printf (CON_ERROR "Map with no planes\n");
return false;
}
// need to save space for box planes
if (count > SANITY_LIMIT(**out))
{
Con_Printf (CON_ERROR "Map has too many leafbrushes\n");
return false;
}
//prv->numbrushes is because of submodels being weird.
out = prv->leafbrushes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+prv->numbrushes));
prv->numleafbrushes = count;
for ( i=0 ; i<count ; i++, in++, out++)
*out = prv->brushes + (unsigned short)(short)LittleShort (*in);
return true;
}
/*
=================
CMod_LoadAreas
=================
*/
static qboolean VBSP_LoadAreas (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i;
carea_t *out;
q2darea_t *in;
int count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadAreas: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count > MAX_Q2MAP_AREAS)
{
Con_Printf (CON_ERROR "Map has too many areas\n");
return false;
}
out = prv->areas = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
prv->numareas = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
out->numareaportals = LittleLong (in->numareaportals);
out->firstareaportal = LittleLong (in->firstareaportal);
}
return true;
}
/*
=================
CMod_LoadVisibility
=================
*/
static qboolean VBSP_LoadVisibility (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i;
prv->numvisibility = l->filelen;
// if (l->filelen > MAX_Q2MAP_VISIBILITY)
// {
// Con_Printf (CON_ERROR "Map has too large visibility lump\n");
// return false;
// }
prv->vis = plugfuncs->GMalloc(&mod->memgroup, l->filelen);
memcpy (prv->vis, mod_base + l->fileofs, l->filelen);
mod->vis = prv->vis;
prv->vis->numclusters = LittleLong (prv->vis->numclusters);
for (i=0 ; i<prv->vis->numclusters ; i++)
{
prv->vis->bitofs[i][0] = LittleLong (prv->vis->bitofs[i][0]);
prv->vis->bitofs[i][1] = LittleLong (prv->vis->bitofs[i][1]);
}
mod->numclusters = prv->vis->numclusters;
mod->pvsbytes = ((mod->numclusters + 31)>>3)&~3;
return true;
}
/*
static qbyte *CM_LeafnumPVS (model_t *model, int leafnum, qbyte *buffer, unsigned int buffersize)
{
return CM_ClusterPVS(model, CM_LeafCluster(model, leafnum), buffer, buffersize);
}
*/
#ifdef HAVE_CLIENT
/*extern int r_dlightframecount;
static void VBSP_MarkLights (dlight_t *light, dlightbitmask_t bit, mnode_t *node)
{
mplane_t *splitplane;
float dist;
msurface_t *surf;
int i;
if (node->contents != -1)
{
mleaf_t *leaf = (mleaf_t *)node;
msurface_t **mark;
i = leaf->nummarksurfaces;
mark = leaf->firstmarksurface;
while(i--!=0)
{
surf = *mark++;
if (surf->dlightframe != r_dlightframecount)
{
surf->dlightbits = 0;
surf->dlightframe = r_dlightframecount;
}
surf->dlightbits |= bit;
}
return;
}
splitplane = node->plane;
dist = DotProduct (light->origin, splitplane->normal) - splitplane->dist;
if (dist > light->radius)
{
VBSP_MarkLights (light, bit, node->children[0]);
return;
}
if (dist < -light->radius)
{
VBSP_MarkLights (light, bit, node->children[1]);
return;
}
// mark the polygons
surf = cl.worldmodel->surfaces + node->firstsurface;
for (i=0 ; i<node->numsurfaces ; i++, surf++)
{
if (surf->dlightframe != r_dlightframecount)
{
surf->dlightbits = 0u;
surf->dlightframe = r_dlightframecount;
}
surf->dlightbits |= bit;
}
VBSP_MarkLights (light, bit, node->children[0]);
VBSP_MarkLights (light, bit, node->children[1]);
}
static void VBSP_StainNode (mnode_t *node, float *parms)
{
mplane_t *splitplane;
float dist;
msurface_t *surf;
int i;
if (node->contents != -1)
return;
splitplane = node->plane;
dist = DotProduct ((parms+1), splitplane->normal) - splitplane->dist;
if (dist > (*parms))
{
VBSP_StainNode (node->children[0], parms);
return;
}
if (dist < (-*parms))
{
VBSP_StainNode (node->children[1], parms);
return;
}
// mark the polygons
surf = cl.worldmodel->surfaces + node->firstsurface;
for (i=0 ; i<node->numsurfaces ; i++, surf++)
{
if (surf->flags&~(SURF_DONTWARP|SURF_PLANEBACK))
continue;
Surf_StainSurf(surf, parms);
}
VBSP_StainNode (node->children[0], parms);
VBSP_StainNode (node->children[1], parms);
}
*/
#endif
typedef struct
{
float vecs[2][4]; // [s/t][xyz offset]
float lmvecs[2][4]; //well that's awkward
int flags; // miptex flags + overrides
int textureindex;
} hltexinfo_t;
static qboolean VBSP_LoadSurfaces (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
hltexinfo_t *in;
q2mapsurface_t *out;
int i, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadSurfaces: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count < 1)
{
Con_Printf (CON_ERROR "Map with no surfaces\n");
return false;
}
// if (count > MAX_Q2MAP_TEXINFO)
// Host_Error ("Map has too many surfaces");
mod->numtexinfo = count;
out = prv->surfaces = plugfuncs->GMalloc(&mod->memgroup, count * sizeof(*prv->surfaces));
for ( i=0 ; i<count ; i++, in++, out++)
{
Q_strncpyz (out->c.name, "FIXME", sizeof(out->c.name));
Q_strncpyz (out->rname, "FIXME", sizeof(out->rname));
out->c.flags = LittleLong (in->flags);
out->c.value = 0;
}
return true;
}
typedef struct
{
vec3_t reflectivity; //not very useful to us.
unsigned int stringindex;
unsigned int width;
unsigned int height;
unsigned int width2; //no idea why there's two of these.
unsigned int height2;
} hltexture_t;
#define TIHL2_LIGHT TI_LIGHT
#define TIHL2_SKYBOX 0x2
#define TIHL2_SKYROOM 0x4
#define TIHL2_WARP TI_WARP
#define TIHL2_TRANS TI_TRANS33
#define TIHL2_NOPORTAL 0x20
#define TIHL2_TRIGGER 0x40
#define TIHL2_NODRAW TI_NODRAW
//#define TIHL2_HINT 0x100
//#define TIHL2_SKIP 0x200
#define TIHL2_NOLIGHT 0x400
//#define TIHL2_BUMPLIGHT 0x800
//#define TIHL2_NOSHADOWS 0x1000
//#define TIHL2_NODECALS 0x2000
//#define TIHL2_NOCHOP 0x4000
//#define TIHL2_HITBOX 0x8000
static qboolean VBSP_LoadTexInfo (model_t *mod, qbyte *mod_base, vlump_t *lumps, char *mapname)
{ //texinfo->textures->stringoffsets->strings. gah, so many lumps just to find the texture name to use!
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
hltexinfo_t *in;
mtexinfo_t *out;
int i, j, count;
char sname[256];
int texcount;
hltexture_t *textures = (void*)(mod_base + lumps[VLUMP_TEXTURES].fileofs);
unsigned int *stringoffsets = (void*)(mod_base + lumps[VLUMP_STRINGOFFSETS].fileofs);
char *strings = mod_base + lumps[VLUMP_STRINGDATA].fileofs;
unsigned int flags;
in = (void *)(mod_base + lumps[VLUMP_TEXINFO].fileofs);
if (lumps[VLUMP_TEXINFO].filelen % sizeof(*in))
{
Con_Printf ("VBSP_LoadTexInfo: funny lump size in %s\n", mod->name);
return false;
}
count = lumps[VLUMP_TEXINFO].filelen / sizeof(*in);
out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));
prv->texinfo = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*prv->texinfo));
mod->textures = plugfuncs->GMalloc(&mod->memgroup, sizeof(texture_t *)*count);
texcount = 0;
mod->texinfo = out;
mod->numtexinfo = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
hltexture_t *texture = ((in->textureindex>=0)?textures + in->textureindex:NULL);
char *texturename = (texture?strings + stringoffsets[texture->stringindex]:"INVALID");
flags = LittleLong (in->flags);
for (j=0 ; j<4 ; j++)
out->vecs[0][j] = LittleFloat (in->vecs[0][j]);
for (j=0 ; j<4 ; j++)
out->vecs[1][j] = LittleFloat (in->vecs[1][j]);
out->vecscale[0] = 1.0/Length (out->vecs[0]);
out->vecscale[1] = 1.0/Length (out->vecs[1]);
for (j=0 ; j<4 ; j++)
prv->texinfo[i].lmvecs[0][j] = LittleFloat (in->lmvecs[0][j]);
for (j=0 ; j<4 ; j++)
prv->texinfo[i].lmvecs[1][j] = LittleFloat (in->lmvecs[1][j]);
if (flags & (TIHL2_SKYBOX|TIHL2_SKYROOM))
Q_snprintfz(sname, sizeof(sname), "sky/%s", texturename);
else
Q_snprintfz(sname, sizeof(sname), "%s", texturename);
if (flags & (TIHL2_WARP))
Q_strncatz(sname, "#WARP", sizeof(sname));
// if (out->flags & TIHL2_FLOWING)
// Q_strncatz(sname, "#FLOW", sizeof(sname));
// if (out->flags & TIHL2_TRANS66)
// Q_strncatz(sname, "#ALPHA=0.66", sizeof(sname));
else if (out->flags & TIHL2_TRANS)
Q_strncatz(sname, "#ALPHA=1", sizeof(sname));
// else if (out->flags & (TIHL2_WARP))
// Q_strncatz(sname, "#ALPHA=1", sizeof(sname));
out->flags = 0;
if (flags & TIHL2_NOLIGHT)
out->flags |= TEX_SPECIAL;
//compact the textures.
for (j=0; j < texcount; j++)
{
if (!Q_strcasecmp(sname, mod->textures[j]->name))
{
out->texture = mod->textures[j];
break;
}
}
if (j == texcount) //load a new one
{
out->texture = plugfuncs->GMalloc(&mod->memgroup, sizeof(texture_t));
Q_strncpyz(out->texture->name, sname, sizeof(out->texture->name));
Q_strlwr(out->texture->name);
if (texture)
{
out->texture->vwidth = texture->width;
out->texture->vheight = texture->height;
}
else
{
out->texture->vwidth = out->texture->vheight = 128;
}
mod->textures[texcount++] = out->texture;
}
}
mod->numtextures = texcount;
return true;
}
typedef struct
{
//shared with q2dnode_t
int planenum;
int children[2]; // negative numbers are -(leafs+1), not nodes
short mins[3]; // for frustom culling
short maxs[3];
unsigned short firstface;
unsigned short numfaces; // counting both sides
//new for hl2
unsigned short area;
unsigned short pad;
} hl2dnode_t;
static qboolean VBSP_LoadNodes (model_t *mod, qbyte *mod_base, vlump_t *l)
{
hl2dnode_t *in;
int child;
mnode_t *out;
int i, j, count;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadNodes: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
if (count < 1)
{
Con_Printf (CON_ERROR "Map has no nodes\n");
return false;
}
if (count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "Map has too many nodes\n");
return false;
}
out = plugfuncs->GMalloc(&mod->memgroup, sizeof(mnode_t)*count);
mod->nodes = out;
mod->numnodes = count;
for (i=0 ; i<count ; i++, out++, in++)
{
memset(out, 0, sizeof(*out));
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleShort (in->mins[j]);
out->minmaxs[3+j] = LittleShort (in->maxs[j]);
}
out->plane = mod->planes + LittleLong(in->planenum);
out->firstsurface = (unsigned short)LittleShort (in->firstface);
out->numsurfaces = (unsigned short)LittleShort (in->numfaces);
out->contents = -1; // differentiate from leafs
for (j=0 ; j<2 ; j++)
{
child = LittleLong (in->children[j]);
out->childnum[j] = child;
if (child < 0)
out->children[j] = (mnode_t *)(mod->leafs + -1-child);
else
out->children[j] = mod->nodes + child;
}
}
VBSP_SetParent (mod->nodes, NULL); // sets nodes and leafs
return true;
}
typedef struct
{
//copied from q2dleaf_t
int contents; // OR of all brushes (NOTE: hl2 doesn't seem to have these all set properly, at least for detail brushes)
short cluster;
short area;
short mins[3]; // for frustum culling
short maxs[3];
unsigned short firstleafface;
unsigned short numleaffaces;
unsigned short firstleafbrush;
unsigned short numleafbrushes;
//new for hl2
short leafwaterid;
struct //present in v19. gone in v20.
{
qbyte rgb[3];
signed char e;
} light[6];
short pad;
} hl2dleaf_t;
static qboolean VBSP_LoadLeafs (model_t *mod, qbyte *mod_base, vlump_t *l, int ver)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i, j;
mleaf_t *out;
hl2dleaf_t *in;
int count;
size_t insize = sizeof(*in);
struct leaflightpoint_s *lightpoint = NULL;
if (ver < 20)
insize = 56; //older maps have some lighting info here.
else
insize = 32;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % insize)
{
Con_Printf (CON_ERROR "VBSP_LoadLeafs: funny lump size\n");
return false;
}
count = l->filelen / insize;
if (count < 1)
{
Con_Printf (CON_ERROR "Map with no leafs\n");
return false;
}
// need to save space for box planes
if (count > SANITY_LIMIT(*out))
{
Con_Printf (CON_ERROR "Map has too many leafs\n");
return false;
}
out = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * (count+1));
mod->numclusters = 0;
mod->leafs = out;
mod->numleafs = count;
if (ver < 20)
{
prv->leaflight = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
lightpoint = plugfuncs->GMalloc(&mod->memgroup, sizeof(*lightpoint) * count);
}
for ( i=0 ; i<count ; i++, in = (hl2dleaf_t*)((qbyte*)in+insize), out++)
{
memset(out, 0, sizeof(*out));
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleShort (in->mins[j]);
out->minmaxs[3+j] = LittleShort (in->maxs[j]);
}
out->contents = VBSP_TranslateContentBits(prv,LittleLong (in->contents));
out->cluster = (unsigned short)LittleShort (in->cluster);
if (out->cluster == 0xffff)
out->cluster = -1;
out->area = (unsigned short)LittleShort (in->area);
out->area &= 0x1ff; //upper part is flags.
out->firstleafbrush = (unsigned short)LittleShort (in->firstleafbrush);
out->numleafbrushes = (unsigned short)LittleShort (in->numleafbrushes);
out->firstmarksurface = mod->marksurfaces +
(unsigned short)LittleShort(in->firstleafface);
out->nummarksurfaces = (unsigned short)LittleShort(in->numleaffaces);
if (out->cluster >= mod->numclusters)
mod->numclusters = out->cluster + 1;
if (lightpoint)
{
for (j = 0; j < 6; j++)
{
float e = pow(2, in->light[j].e);
lightpoint->rgb[j][0] = e * in->light[j].rgb[0];
lightpoint->rgb[j][1] = e * in->light[j].rgb[1];
lightpoint->rgb[j][2] = e * in->light[j].rgb[2];
}
prv->leaflight[i].count = 1;
prv->leaflight[i].point = lightpoint++;
}
}
mod->pvsbytes = ((mod->numclusters + 31)>>3)&~3;
return true;
}
typedef struct
{
unsigned short portalnum;
unsigned short otherarea;
unsigned short firstvert;
unsigned short numverts;
unsigned int planenum;
} hl2dareaportal_t;
static qboolean VBSP_LoadAreaPortals (model_t *mod, qbyte *mod_base, vlump_t *l, vlump_t *lump_verts)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i;
q2dareaportal_t *out;
hl2dareaportal_t *in;
int count, vcount;
vec3_t *inverts;
mesh_t mesh;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadAreaPortals: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
inverts = (void *)(mod_base + lump_verts->fileofs);
if (lump_verts->filelen % sizeof(*inverts))
{
Con_Printf (CON_ERROR "VBSP_LoadAreaPortals: funny lump size\n");
return false;
}
vcount = lump_verts->filelen / sizeof(*inverts);
if (count > MAX_Q2MAP_AREAS)
{
Con_Printf (CON_ERROR "Map has too many areas\n");
return false;
}
out = prv->areaportals = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
prv->portalpoly = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->portalpoly)*count);
prv->portalplane = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->portalplane)*count);
prv->numareaportals = count;
mesh.xyz_array = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.xyz_array)*vcount);
for (i=0 ; i<vcount ; i++)
{
mesh.xyz_array[i][0] = LittleFloat(inverts[i][0]);
mesh.xyz_array[i][1] = LittleFloat(inverts[i][1]);
mesh.xyz_array[i][2] = LittleFloat(inverts[i][2]);
}
mesh.indexes = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.indexes)*64*3);
mesh.st_array = plugfuncs->GMalloc(&mod->memgroup, sizeof(*mesh.st_array)*64);
for (i=0 ; i<64 ; i++)
{
Vector2Set(mesh.st_array[i], 0,0);
mesh.indexes[i*3+0] = 0;
mesh.indexes[i*3+1] = i+1;
mesh.indexes[i*3+2] = i+2;
}
for (i=0 ; i<count ; i++, in++, out++)
{
out->portalnum = LittleShort (in->portalnum);
out->otherarea = LittleShort (in->otherarea);
prv->portalplane[i] = mod->planes + LittleLong (in->planenum);
prv->portalpoly[i].xyz_array = mesh.xyz_array+LittleLong(in->firstvert);
prv->portalpoly[i].st_array = mesh.st_array;
prv->portalpoly[i].numvertexes = LittleLong(in->numverts);
if (prv->portalpoly[i].numvertexes>2)
{
prv->portalpoly[i].istrifan = true;
prv->portalpoly[i].indexes = mesh.indexes;
prv->portalpoly[i].numindexes = (prv->portalpoly[i].numvertexes-2)*3;
}
}
return true;
}
typedef struct
{ //the main displacement lump
vec3_t position; //not really sure how to use this.
int firstvert; //((1<<power)+1) squared verts
int firsttriflags; //ignored (two shorts per quad)
int power;
int minpower; //ignored... FIXME: add lod...
float smoothangle;
unsigned int contents;
unsigned short faceidx; //mod->surfaces index
unsigned int lightmapalphaoffset; //erk, rgba? that's going to restrict lightmap formats.
unsigned int lightofs; //extents? cabbage? oh noes we've gone mad again! or is this some special blend weights in addition to the surface's lighting?
struct
{ //erk
unsigned short peer;
unsigned char orientation;
unsigned char span;
unsigned char peerspan;
} edgepeers[8]; //two per edge
struct
{ //no idea how this works
unsigned short peer[4];
unsigned char numpeers;
} cornerpeers[4];
unsigned int allowedverts[10];
} hl2ddisplacement_t;
typedef struct
{
vec3_t norm;
float dist;
float alpha; //vertex alpha.
} hl2displacementvert_t;
static qboolean VBSP_LoadDisplacements (model_t *mod, qbyte *mod_base, vlump_t *lumps)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
vlump_t *l = &lumps[VLUMP_DISP_INFO];
vlump_t *vl = &lumps[VLUMP_DISP_VERTS];
hl2ddisplacement_t *in;
dispinfo_t *out;
int i, count, x, y;
hl2displacementvert_t *inv;
struct dispvert_s *verts;
vecV_t *xyz;
index_t *indexes;
size_t maxverts;
msurface_t *surf;
float *sverts[4];
signed int e, idx;
float fx,fy;
vec3_t p, base;
size_t stride;
int primary;
float pdist,dist;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf ("VBSP_LoadDisplacements: funny lump size in %s\n",mod->name);
return false;
}
count = l->filelen / sizeof(*in);
if (!count)
return true; //nothing to worry about.
out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));
for (maxverts = 0, i = 0; i < count; i++)
maxverts += ((1<<in[i].power)) * ((1<<in[i].power));
indexes = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*indexes)*6);
for (maxverts = 0, i = 0; i < count; i++)
maxverts += ((1<<in[i].power)+1) * ((1<<in[i].power)+1);
verts = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*verts));
xyz = plugfuncs->GMalloc(&mod->memgroup, maxverts*sizeof(*xyz));
prv->displacements = out;
prv->numdisplacements = count;
for (i = 0; i < count; i++, out++, in++)
{
surf = mod->surfaces + in->faceidx;
if (surf->numedges != 4)
{
Con_Printf ("VBSP_LoadDisplacements: displacement surface doesn't have 4 edges in %s\n",mod->name);
return false;
}
//find the 4 verts... messy.
for (x = 0; x < 4; x++)
{
e = mod->surfedges[surf->firstedge+x];
idx = e < 0;
if (idx)
e = -e;
if (e < 0 || e >= mod->numedges)
sverts[x] = mod->vertexes[0].position;
else
sverts[x] = mod->vertexes[mod->edges[e].v[idx]].position;
}
//this is just stupid and pointless.
//the in->position point tells us which point is the primary one, instead of just rotating the edges.
primary = 0;
pdist = FLT_MAX;
for (x = 0; x < 4; x++)
{
VectorSubtract(sverts[x], in->position, p);
dist = DotProduct(p,p);
if (dist < pdist)
{
pdist = dist;
primary = x;
}
}
out->surf = surf;
prv->surfdisp[in->faceidx] = out; //the surface needs to be able to get its proper info when building vbos
ClearBounds(out->aamin, out->aamax);
out->contents = VBSP_TranslateContentBits(prv,in->contents);
out->width = (1<<in->power);
out->height = (1<<in->power);
out->idx = indexes;
stride = out->width+1;
for (y=0 ; y<out->height ; y++)
for (x=0 ; x<out->width ; x++)
{
if ((x+y)&1)
{ //a diamond pattern - flipping alternately
*indexes++ = (x+0)+(y+1)*stride;
*indexes++ = (x+1)+(y+1)*stride;
*indexes++ = (x+1)+(y+0)*stride;
*indexes++ = (x+0)+(y+1)*stride;
*indexes++ = (x+1)+(y+0)*stride;
*indexes++ = (x+0)+(y+0)*stride;
}
else
{
*indexes++ = (x+0)+(y+0)*stride;
*indexes++ = (x+0)+(y+1)*stride;
*indexes++ = (x+1)+(y+1)*stride;
*indexes++ = (x+0)+(y+0)*stride;
*indexes++ = (x+1)+(y+1)*stride;
*indexes++ = (x+1)+(y+0)*stride;
}
}
out->numindexes = indexes - out->idx;
inv = (void *)(mod_base + vl->fileofs);
inv += in->firstvert;
out->verts = verts;
out->xyz = xyz;
for (y = 0; y <= out->height; y++)
for (x = 0; x <= out->width; x++)
{
//I have no idea if this is right. probably not. oh well.
fx = (float)x/out->width;
fy = (float)y/out->height;
VectorClear(base);
VectorMA(base, (1-fx)*(1-fy), sverts[(primary+0)&3], base);
VectorMA(base, (1-fx)*( fy), sverts[(primary+1)&3], base);
VectorMA(base, ( fx)*( fy), sverts[(primary+2)&3], base);
VectorMA(base, ( fx)*(1-fy), sverts[(primary+3)&3], base);
verts->st[0] = DotProduct(base, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
verts->st[1] = DotProduct(base, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
VectorScale(inv->norm, inv->dist*hl2_displacement_scale->value, p);
VectorNormalize2(p, verts->norm);
VectorAdd(base, p, (*xyz));
verts->alpha = inv->alpha;
AddPointToBounds((*xyz), out->aamin, out->aamax);
inv++;
verts++;
xyz++;
}
surf->mesh->numindexes = out->numindexes;
surf->mesh->numvertexes = verts-out->verts;
}
return true;
}
typedef struct
{
short planenum;
qbyte side;
qbyte onnode; //o.O
int firstedge; // we must support > 64k edges
unsigned short numedges;
unsigned short texinfo;
unsigned short dispinfo;
short fogvolume;
// lighting info
qbyte styles[4];
int lightofs; // start of [numstyles*surfsize] samples
float surfacearea;
int extents_min[2];
int extents_size[2];
int origface;
unsigned short numprims;
unsigned short firstprim;
unsigned int smoothinggroup;
} hl2dface_t;
static qboolean VBSP_LoadFaces (model_t *mod, qbyte *mod_base, vlump_t *lumps, int version)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
vlump_t *l = &lumps[VLUMP_FACES_LDR];
vlump_t *l2 = &lumps[VLUMP_FACES_HDR];
hl2dface_t *in;
msurface_t *out;
int i, count, surfnum;
int planenum;
int ti, st;
int lumpsize = sizeof(*in);
mesh_t *meshes;
if (l2->filelen && !(hl2_favour_ldr->ival && lumps[VLUMP_LIGHTING_LDR].filelen))
l = l2;
if (version == 18)
{ //this version seems to have rgbx*4 prefixed
in = (void *)(mod_base + l->fileofs + 4*4);
lumpsize += 4*4;
}
else
in = (void *)(mod_base + l->fileofs);
if (l->filelen % lumpsize)
{
Con_Printf ("VBSP_LoadFaces: funny lump size in %s\n",mod->name);
return false;
}
count = l->filelen / lumpsize;
out = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*out));
prv->surfdisp = plugfuncs->GMalloc(&mod->memgroup, count * sizeof(*prv->surfdisp));
meshes = plugfuncs->GMalloc(&mod->memgroup, count*sizeof(*meshes));
mod->surfaces = out;
mod->numsurfaces = count;
mod->lightmaps.surfstyles = 1;
for ( surfnum=0 ; surfnum<count ; surfnum++, in = (void*)((qbyte*)in+lumpsize), out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = (unsigned short)LittleShort(in->numedges);
out->flags = 0;
out->mesh = meshes+surfnum;
out->mesh->numvertexes = out->numedges;
out->mesh->numindexes = (out->mesh->numvertexes-2)*3;
planenum = (unsigned short)LittleShort(in->planenum);
if (in->side)
out->flags |= SURF_PLANEBACK;
if (!in->onnode)
out->flags |= SURF_OFFNODE;
out->plane = mod->planes + planenum;
ti = (unsigned short)LittleShort (in->texinfo);
if (ti < 0 || ti >= mod->numtexinfo)
{
Con_Printf (CON_ERROR "VBSP_LoadFaces: bad texinfo number\n");
return false;
}
out->texinfo = mod->texinfo + ti;
if (out->texinfo->flags & TI_SKY)
{
out->flags |= SURF_DRAWSKY;
}
if (out->texinfo->flags & TI_WARP)
{
out->flags |= SURF_DRAWTURB|SURF_DRAWTILED;
}
out->lmshift = 0;
out->texturemins[0] = in->extents_min[0];
out->texturemins[1] = in->extents_min[1];
out->extents[0] = in->extents_size[0];
out->extents[1] = in->extents_size[1];
// lighting info
for (i=0 ; i<Q1Q2BSP_STYLESPERSURF ; i++)
{
st = in->styles[i];
if (st == 255)
st = INVALID_LIGHTSTYLE;
else if (mod->lightmaps.maxstyle < st)
mod->lightmaps.maxstyle = st;
out->styles[i] = st;
}
for (; i<MAXCPULIGHTMAPS ; i++)
out->styles[i] = INVALID_LIGHTSTYLE;
for (i = 0; i<MAXRLIGHTMAPS ; i++)
out->vlstyles[i] = INVALID_VLIGHTSTYLE;
i = LittleLong(in->lightofs);
if (i == -1 || !mod->lightdata)
out->samples = NULL;
else
out->samples = mod->lightdata + i;
// set the drawing flags
if (out->texinfo->flags & TI_WARP)
out->flags |= SURF_DRAWTURB;
}
return true;
}
#ifdef HAVE_CLIENT
static void VBSP_BuildSurfMesh(model_t *mod, msurface_t *surf, builddata_t *bd)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
unsigned int vertidx;
int i, lindex, edgevert;
mesh_t *mesh = surf->mesh;
float *vec;
float s, t, miss;
int sty;
struct vbsptexinfo_s *vtexinfo;
//displacement surfaces...
dispinfo_t *d = prv->surfdisp[surf-mod->surfaces];
if (d)
{
struct dispvert_s *dv = d->verts;
mesh->istrifan = false;
memcpy(mesh->indexes, d->idx, sizeof(index_t)*d->numindexes);
//output the renderable verticies
for (i=0 ; i<mesh->numvertexes ; i++, dv++)
{
//xyz
VectorCopy (d->xyz[i], mesh->xyz_array[i]);
//st
mesh->st_array[i][0] = dv->st[0];
mesh->st_array[i][1] = dv->st[1];
if (surf->texinfo->texture->vwidth)
mesh->st_array[i][0] /= surf->texinfo->texture->vwidth;
if (surf->texinfo->texture->vheight)
mesh->st_array[i][1] /= surf->texinfo->texture->vheight;
//lmst
s = (float)(i%(d->width+1))/d->width;
t = (float)(i/(d->width+1))/d->height;
for (sty = 0; sty < 1; sty++)
{
mesh->lmst_array[sty][i][0] = (s*surf->extents[0] + surf->light_s[sty] + 0.5) / (mod->lightmaps.width);
mesh->lmst_array[sty][i][1] = (t*surf->extents[1] + surf->light_t[sty] + 0.5) / (mod->lightmaps.height);
}
//normals
VectorCopy(surf->plane->normal, mesh->normals_array[i]);
VectorCopy(surf->texinfo->vecs[0], mesh->snormals_array[i]);
VectorNegate(surf->texinfo->vecs[1], mesh->tnormals_array[i]);
//rgba
for (sty = 0; sty < 1; sty++)
{
mesh->colors4f_array[sty][i][0] = 1;
mesh->colors4f_array[sty][i][1] = 1;
mesh->colors4f_array[sty][i][2] = 1;
mesh->colors4f_array[sty][i][3] = ((int)dv->alpha&255)/255.0;
}
}
return;
}
//regular surfaces...
mesh->istrifan = true;
//output the mesh's indicies
for (i=0 ; i<mesh->numvertexes-2 ; i++)
{
mesh->indexes[i*3] = 0;
mesh->indexes[i*3+1] = i+1;
mesh->indexes[i*3+2] = i+2;
}
//output the renderable verticies
for (i=0 ; i<mesh->numvertexes ; i++)
{
lindex = mod->surfedges[surf->firstedge + i];
edgevert = lindex <= 0;
if (edgevert)
lindex = -lindex;
if (lindex < 0 || lindex >= mod->numedges)
vertidx = 0;
else
vertidx = mod->edges[lindex].v[edgevert];
vec = mod->vertexes[vertidx].position;
s = DotProduct (vec, surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
t = DotProduct (vec, surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
VectorCopy (vec, mesh->xyz_array[i]);
mesh->st_array[i][0] = s;
mesh->st_array[i][1] = t;
if (surf->texinfo->texture->vwidth)
mesh->st_array[i][0] /= surf->texinfo->texture->vwidth;
if (surf->texinfo->texture->vheight)
mesh->st_array[i][1] /= surf->texinfo->texture->vheight;
vtexinfo = &prv->texinfo[surf->texinfo-mod->texinfo];
s = DotProduct (vec, vtexinfo->lmvecs[0]) + vtexinfo->lmvecs[0][3];
t = DotProduct (vec, vtexinfo->lmvecs[1]) + vtexinfo->lmvecs[1][3];
for (sty = 0; sty < 1; sty++)
{
mesh->lmst_array[sty][i][0] = (s - surf->texturemins[0] + (surf->light_s[sty]<<surf->lmshift) + (1<<surf->lmshift)*0.5) / (mod->lightmaps.width<<surf->lmshift);
mesh->lmst_array[sty][i][1] = (t - surf->texturemins[1] + (surf->light_t[sty]<<surf->lmshift) + (1<<surf->lmshift)*0.5) / (mod->lightmaps.height<<surf->lmshift);
}
//figure out the texture directions, for bumpmapping and stuff
if (surf->flags & SURF_PLANEBACK)
VectorNegate(surf->plane->normal, mesh->normals_array[i]);
else
VectorCopy(surf->plane->normal, mesh->normals_array[i]);
VectorCopy(surf->texinfo->vecs[0], mesh->snormals_array[i]);
VectorNegate(surf->texinfo->vecs[1], mesh->tnormals_array[i]);
//the s+t vectors are axis-aligned, so fiddle them so they're normal aligned instead
miss = -DotProduct(mesh->normals_array[i], mesh->snormals_array[i]);
VectorMA(mesh->snormals_array[i], miss, mesh->normals_array[i], mesh->snormals_array[i]);
miss = -DotProduct(mesh->normals_array[i], mesh->tnormals_array[i]);
VectorMA(mesh->tnormals_array[i], miss, mesh->normals_array[i], mesh->tnormals_array[i]);
VectorNormalize(mesh->snormals_array[i]);
VectorNormalize(mesh->tnormals_array[i]);
//q1bsp has no colour information (fixme: sample from the lightmap?)
for (sty = 0; sty < 1; sty++)
{
mesh->colors4f_array[sty][i][0] = 1;
mesh->colors4f_array[sty][i][1] = 1;
mesh->colors4f_array[sty][i][2] = 1;
mesh->colors4f_array[sty][i][3] = 1;
}
}
}
static void VBSP_LoadLighting (model_t *mod, qbyte *mod_base, vlump_t *ldr, vlump_t *hdr)
{
qbyte *src;
unsigned int *out;
size_t count;
if (hdr->filelen && !(hl2_favour_ldr->ival && ldr->filelen))
{
mod->lightdatasize = hdr->filelen;
src = (mod_base + hdr->fileofs);
}
else if (ldr->filelen)
{
mod->lightdatasize = ldr->filelen;
src = (mod_base + ldr->fileofs);
}
else
return;
mod->lightmaps.fmt = LM_E5BGR9;
mod->lightdata = (qbyte*)(out = plugfuncs->GMalloc(&mod->memgroup, mod->lightdatasize));
//convert from linear e8bgr8 to srgb e5bgr9
for (count = mod->lightdatasize/4; count --> 0; src+=4)
{
int e = 0;
float m;
float scale;
unsigned int hdr;
vec3_t rgb;
//decode input
m = pow(2, (signed char)src[3])/255.0;
rgb[0] = m * src[0];
rgb[1] = m * src[1];
rgb[2] = m * src[2];
//rescale its gamma ramp to something we can actually use properly
rgb[0] = M_LinearToSRGB(rgb[0], 1.0);
rgb[1] = M_LinearToSRGB(rgb[1], 1.0);
rgb[2] = M_LinearToSRGB(rgb[2], 1.0);
//encode output
m = max(max(rgb[0], rgb[1]), rgb[2]);
if (m < 0)
m = 0;
if (m >= 0.5)
{ //positive exponent
while (m >= (1<<(e)) && e < 30-15) //don't do nans.
e++;
}
else
{ //negative exponent...
while (m < 1/(1<<-e) && e > -14) //don't do denormals.
e--;
}
scale = pow(2, e-9);
hdr = ((e+15)<<27);
hdr |= bound(0, (int)(rgb[0]/scale + 0.5), 0x1ff)<<0;
hdr |= bound(0, (int)(rgb[1]/scale + 0.5), 0x1ff)<<9;
hdr |= bound(0, (int)(rgb[2]/scale + 0.5), 0x1ff)<<18;
*out++ = hdr;
}
}
#endif
typedef struct
{
unsigned short planenum;
short texinfo;
unsigned short dispinfo;
short bevel;
} hl2dbrushside_t;
static qboolean VBSP_LoadBrushSides (model_t *mod, qbyte *mod_base, vlump_t *l)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
unsigned int i, j;
q2cbrushside_t *out;
hl2dbrushside_t *in;
int count;
int num;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Con_Printf (CON_ERROR "VBSP_LoadBrushSides: funny lump size\n");
return false;
}
count = l->filelen / sizeof(*in);
// need to save space for box planes
if (count > SANITY_MAX_MAP_BRUSHSIDES)
{
Con_Printf (CON_ERROR "Map has too many brushsides (%i)\n", count);
return false;
}
out = prv->brushsides = plugfuncs->GMalloc(&mod->memgroup, sizeof(*out) * count);
prv->numbrushsides = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
num = (unsigned short)LittleShort (in->planenum);
out->plane = &mod->planes[num];
j = (unsigned short)LittleShort (in->texinfo);
if (j >= mod->numtexinfo)
out->surface = &nullsurface;
else
out->surface = &prv->surfaces[j];
}
return true;
}
typedef struct {
unsigned int count;
struct {
unsigned int id;
unsigned short flags;
unsigned short version;
unsigned int ofs;
unsigned int len;
} sl[1];
} hlgamelumpheader_t;
static qboolean VBSP_LoadStaticProps(model_t *mod, qbyte *offset, size_t size, int version) //present on server, because they're potentially solid.
{
vbspinfo_t *prv = mod->meshinfo;
struct {
const char name[128];
} *modelref;
size_t nummodels, numleafrefs, numprops, i;
unsigned short *leafref, *eleafref;
struct staticprop_s *sent;
entity_t *ent;
size_t modelindex;
qboolean skip = false;
int dxlevel = 95, cpulevel=0, gpulevel=0;
unsigned int leafcount, l;
qbyte *prop;
size_t propsize;
switch(version)
{
case 4:
propsize = 14*4;
break;
case 5: //+scale
propsize = 15*4;
break;
case 6://+dxlevels
propsize = 16*4;
break;
case 7: //+rgba
case 8: //-dxlevels+[cg]pulevels
propsize = 17*4;
break;
case 9: //+360
case 10://-360+flags
propsize = 18*4;
break;
case 11://+scale
propsize = 19*4;
break;
default:
return true; //version not supported, just ignore it entirely. sorry.
}
nummodels = LittleLong(*(int*)offset);
offset += 4;
size -= 4;
modelref = (void*)offset;
offset += nummodels*sizeof(*modelref);
size -= nummodels*sizeof(*modelref);
numleafrefs = LittleLong(*(int*)offset);
offset += 4;
size -= 4;
leafref = (void*)offset;
offset += numleafrefs*sizeof(*leafref);
size -= numleafrefs*sizeof(*leafref);
numprops = LittleLong(*(int*)offset);
offset += 4;
size -= 4;
prop = (void*)offset;
offset += numprops*propsize;
size -= numprops*propsize;
if (size)
return true; //funny lump size...
prv->staticprops = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->staticprops)*numprops);
for (i = 0, sent = prv->staticprops; i < numprops; i++)
{
ent = &sent->ent;
skip = false;
ent->playerindex = -1;
ent->topcolour = TOP_DEFAULT;
ent->bottomcolour = BOTTOM_DEFAULT;
ent->scale = 1;
ent->shaderRGBAf[0] = 1;
ent->shaderRGBAf[1] = 1;
ent->shaderRGBAf[2] = 1;
ent->shaderRGBAf[3] = 1;
ent->framestate.g[FS_REG].frame[0] = 0;
ent->framestate.g[FS_REG].lerpweight[0] = 1;
ent->origin[0] = LittleFloat(*(float*)prop); prop += sizeof(float);
ent->origin[1] = LittleFloat(*(float*)prop); prop += sizeof(float);
ent->origin[2] = LittleFloat(*(float*)prop); prop += sizeof(float);
ent->angles[0] = LittleFloat(*(float*)prop); prop += sizeof(float);
ent->angles[1] = LittleFloat(*(float*)prop); prop += sizeof(float);
ent->angles[2] = LittleFloat(*(float*)prop); prop += sizeof(float);
modelindex = (unsigned short)LittleShort(*(short*)prop); prop += sizeof(unsigned short);
eleafref = leafref+(unsigned short)LittleShort(*(unsigned short*)prop); prop += sizeof(unsigned short);
leafcount = LittleShort(*(unsigned short*)prop); prop += sizeof(unsigned short);
sent->solid = *prop; prop += sizeof(qbyte);
/*ent->flags = *prop*/; prop += sizeof(qbyte);
ent->skinnum = LittleLong(*(unsigned int*)prop); prop += sizeof(unsigned int);
sent->fademindist = LittleFloat(*(float*)prop); prop += sizeof(float);
sent->fademaxdist = LittleFloat(*(float*)prop); prop += sizeof(float);
sent->lightorg[0] = LittleFloat(*(float*)prop); prop += sizeof(float);
sent->lightorg[1] = LittleFloat(*(float*)prop); prop += sizeof(float);
sent->lightorg[2] = LittleFloat(*(float*)prop); prop += sizeof(float);
if (version >= 5)
{
/*ent->fadescale = LittleFloat(*(float*)prop);*/ prop += sizeof(float);
}
if (version >= 8)
{
skip |= (prop[0] > cpulevel || cpulevel > prop[1]); prop += sizeof(qbyte)*2;
skip |= (prop[0] > gpulevel || gpulevel > prop[1]); prop += sizeof(qbyte)*2;
}
else if (version >= 6)
{
unsigned short minlev, maxlev;
minlev = LittleShort(*(unsigned short*)prop); prop += sizeof(unsigned short);
maxlev = LittleShort(*(unsigned short*)prop); prop += sizeof(unsigned short);
skip |= (minlev > dxlevel || dxlevel > maxlev);
}
if (version >= 7)
{
VectorScale(prop, 1/255.0, ent->shaderRGBAf); prop += sizeof(qbyte)*4;
}
if (version == 9)
{
/*disablex360 = LittleLong(*(int*)prop);*/ prop += sizeof(int);
}
if (version >= 10)
{
ent->flags = LittleLong(*(int*)prop); prop += sizeof(int);
}
if (version >= 11)
{
ent->scale = LittleFloat(*(float*)prop); prop += sizeof(float);
}
//okay, we parsed the prop data now...
skip |= modelindex >= nummodels;
if (skip)
continue; //we're ignoring it for some reason
ent->model = modfuncs->BeginSubmodelLoad(modelref[modelindex].name);
modfuncs->AngleVectors(ent->angles, ent->axis[0], ent->axis[1], ent->axis[2]);
VectorNegate(ent->axis[1],ent->axis[1]);
//transforms, in case we need to recursively walk its bih
VectorCopy(ent->axis[0], prv->staticprops[i].transform.axis[0]);
VectorCopy(ent->axis[1], prv->staticprops[i].transform.axis[1]);
VectorCopy(ent->axis[2], prv->staticprops[i].transform.axis[2]);
VectorCopy(ent->origin, prv->staticprops[i].transform.origin);
//Hack: special value to flag it for linking once we've loaded its model. this needs to go when we make them solid.
if (leafcount > countof(ent->pvscache.leafnums))
ent->pvscache.num_leafs = -2; //overflow. calculate it later once its loaded.
else
{
ent->pvscache.areanum = -1; //FIXME
ent->pvscache.areanum2 = -1;
ent->pvscache.num_leafs = leafcount; //overflow. calculate it later once its loaded.
for (l = 0; l < leafcount; l++)
{
mleaf_t *lf = mod->leafs + *eleafref++;
ent->pvscache.leafnums[l]/*actually clusters*/ = lf->cluster;
//and try to track the areas too. not quite so reliable...
if (ent->pvscache.areanum == -1)
ent->pvscache.areanum = lf->area;
else
ent->pvscache.areanum2 = lf->area;
}
}
//Hack: lighting is wrong.
// ent->light_type = ELT_UNKNOWN;
VectorSet(ent->light_dir, 0, 0.707, 0.707);
VectorSet(ent->light_avg, 0.75, 0.75, 0.75);
VectorSet(ent->light_range, 0.5, 0.5, 0.5);
//not all props will be emitted, according to d3d levels...
prv->numstaticprops++;
sent++;
}
return true;
}
static qboolean VBSP_LoadGameLump(model_t *mod, qbyte *mod_base, vlump_t *l)
{
size_t i;
hlgamelumpheader_t *blob = (void*)(mod_base + l->fileofs);
if (!l->filelen)
return true; //missing
if (l->filelen < sizeof(*blob) + sizeof(*blob->sl)*(blob->count-1))
return false; //not even enough space for the header...
for (i = 0; i < blob->count; i++)
{
#define LUMPTYPE(a,b,c,d, minver, maxver) (blob->sl[i].id == (((qbyte)a<<24)|((qbyte)b<<16)|((qbyte)c<<8)|((qbyte)d<<0)) && blob->sl[i].version >= minver && blob->sl[i].version <= maxver)
if (LUMPTYPE('s','p','r','p', 4,10) && !blob->sl[i].flags) //static props (placed by mapper)
VBSP_LoadStaticProps(mod, mod_base+blob->sl[i].ofs/*sigh*/, blob->sl[i].len, blob->sl[i].version);
else if (LUMPTYPE('d','p','r','p', 4,4) && !blob->sl[i].flags) //dynamic props (generated by textures)
;
else if (LUMPTYPE('d','p','l','t', 0,0) && !blob->sl[i].flags) //detail prop ldr lighting
;
else if (LUMPTYPE('d','p','l','h', 0,0) && !blob->sl[i].flags) //detail prop hdr lighting
;
else
Con_Printf("Unsupported gamelump id/version %c%c%c%c %i\n", (blob->sl[i].id>>24),(blob->sl[i].id>>16),(blob->sl[i].id>>8),(blob->sl[i].id>>0),blob->sl[i].version);
#undef LUMPTYPE
}
return true;
}
#ifdef HAVE_CLIENT
static void VBSP_GenerateMaterials(void *ctx, void *data, size_t a, size_t b)
{
model_t *mod = ctx;
const char *script;
if (!a)
{ //submodels share textures, so only do this if 'a' is 0 (inline index, 0 = world).
for(a = 0; a < mod->numtextures; a++)
{
script = NULL;
if (!strncmp(mod->textures[a]->name, "sky/", 4))
script =
"{\n"
"sort sky\n"
"surfaceparm nodlight\n"
"skyparms - - -\n"
"}\n";
mod->textures[a]->shader = modfuncs->RegisterBasicShader(mod, mod->textures[a]->name, SUF_LIGHTMAP, script, PTI_INVALID, 0, 0, NULL, NULL);
}
}
modfuncs->Batches_Build(mod, data);
if (data)
plugfuncs->Free(data);
}
#endif
/*
==================
CM_InlineModel
==================
*/
static cmodel_t *VBSP_InlineModel (model_t *model, char *name)
{
vbspinfo_t *prv = (vbspinfo_t*)model->meshinfo;
int num;
if (!name)
Host_Error("Bad model\n");
else if (name[0] != '*')
Host_Error("Bad model\n");
num = atoi (name+1);
if (num < 1 || num >= prv->numcmodels)
Host_Error ("CM_InlineModel: bad number");
return &prv->cmodels[num];
}
static int VBSP_NumInlineModels (model_t *model)
{
vbspinfo_t *prv = (vbspinfo_t*)model->meshinfo;
return prv->numcmodels;
}
static int VBSP_LeafContents (model_t *model, int leafnum)
{
if (leafnum < 0 || leafnum >= model->numleafs)
Host_Error ("CM_LeafContents: bad number");
return model->leafs[leafnum].contents;
}
static int VBSP_LeafCluster (model_t *model, int leafnum)
{
if (leafnum < 0 || leafnum >= model->numleafs)
Host_Error ("CM_LeafCluster: bad number");
return model->leafs[leafnum].cluster;
}
static int VBSP_LeafArea (model_t *model, int leafnum)
{
if (leafnum < 0 || leafnum >= model->numleafs)
Host_Error ("CM_LeafArea: bad number");
return model->leafs[leafnum].area;
}
//=======================================================================
/*
==================
CM_PointLeafnum_r
==================
*/
static int VBSP_PointLeafnum_r (model_t *mod, const vec3_t p, int num)
{
float d;
mnode_t *node;
mplane_t *plane;
while (num >= 0)
{
node = mod->nodes + num;
plane = node->plane;
if (plane->type < 3)
d = p[plane->type] - plane->dist;
else
d = DotProduct (plane->normal, p) - plane->dist;
if (d < 0)
num = node->childnum[1];
else
num = node->childnum[0];
}
return -1 - num;
}
static int VBSP_PointLeafnum (model_t *mod, const vec3_t p)
{
if (mod->loadstate != MLS_LOADED)
return 0; // sound may call this without map loaded
return VBSP_PointLeafnum_r (mod, p, 0);
}
static int VBSP_PointCluster (model_t *mod, const vec3_t p, int *area)
{
int leaf;
if (mod->loadstate != MLS_LOADED)
return 0; // sound may call this without map loaded
leaf = VBSP_PointLeafnum_r (mod, p, 0);
if (area)
*area = VBSP_LeafArea(mod, leaf);
return VBSP_LeafCluster(mod, leaf);
}
static unsigned int VBSP_PointContents (model_t *mod, const vec3_t axis[3], const vec3_t p)
{
vec3_t np;
if (mod->loadstate != MLS_LOADED)
return 0;
if (axis)
{
np[0] = DotProduct(p, axis[0]);
np[1] = DotProduct(p, axis[1]);
np[2] = DotProduct(p, axis[2]);
p = np;
}
return VBSP_LeafContents(mod, VBSP_PointLeafnum_r (mod, p, 0));
}
/*
=============
CM_BoxLeafnums
Fills in a list of all the leafs touched
=============
*/
static int leaf_count, leaf_maxcount;
static int *leaf_list;
static const float *leaf_mins, *leaf_maxs;
static int leaf_topnode;
static void VBSP_BoxLeafnums_r (model_t *mod, int nodenum)
{
mplane_t *plane;
mnode_t *node;
int s;
while (1)
{
if (nodenum < 0)
{
if (leaf_count >= leaf_maxcount)
return;
leaf_list[leaf_count++] = -1 - nodenum;
return;
}
node = &mod->nodes[nodenum];
plane = node->plane;
// s = BoxOnPlaneSide (leaf_mins, leaf_maxs, plane);
s = BOX_ON_PLANE_SIDE(leaf_mins, leaf_maxs, plane);
if (s == 1)
nodenum = node->childnum[0];
else if (s == 2)
nodenum = node->childnum[1];
else
{ // go down both
if (leaf_topnode == -1)
leaf_topnode = nodenum;
VBSP_BoxLeafnums_r (mod, node->childnum[0]);
nodenum = node->childnum[1];
}
}
}
static int VBSP_BoxLeafnums_headnode (model_t *mod, const vec3_t mins, const vec3_t maxs, int *list, int listsize, int headnode, int *topnode)
{
leaf_list = list;
leaf_count = 0;
leaf_maxcount = listsize;
leaf_mins = mins;
leaf_maxs = maxs;
leaf_topnode = -1;
VBSP_BoxLeafnums_r (mod, headnode);
if (topnode)
*topnode = leaf_topnode;
return leaf_count;
}
static int VBSP_BoxLeafnums (model_t *mod, const vec3_t mins, const vec3_t maxs, int *list, int listsize, int *topnode)
{
return VBSP_BoxLeafnums_headnode (mod, mins, maxs, list,
listsize, mod->hulls[0].firstclipnode, topnode);
}
static void VBSP_FindTouchedLeafs(model_t *model, struct pvscache_s *ent, const float *mins, const float *maxs)
{
#define MAX_TOTAL_ENT_LEAFS 128
int leafs[MAX_TOTAL_ENT_LEAFS];
int clusters[MAX_TOTAL_ENT_LEAFS];
int num_leafs;
int topnode;
int i, j;
int area;
int nullarea = -1;
//ent->num_leafs == q2's ent->num_clusters
ent->num_leafs = 0;
ent->areanum = nullarea;
ent->areanum2 = nullarea;
if (!mins || !maxs)
return;
//get all leafs, including solids
num_leafs = VBSP_BoxLeafnums (model, mins, maxs,
leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
// set areas
for (i=0 ; i<num_leafs ; i++)
{
clusters[i] = VBSP_LeafCluster (model, leafs[i]);
area = VBSP_LeafArea (model, leafs[i]);
if (area != nullarea)
{ // doors may legally straggle two areas,
// but nothing should ever need more than that
if (ent->areanum != nullarea && ent->areanum != area)
ent->areanum2 = area;
else
ent->areanum = area;
}
}
if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_leafs = -1;
ent->headnode = topnode;
}
else
{
ent->num_leafs = 0;
for (i=0 ; i<num_leafs ; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j=0 ; j<i ; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_leafs == MAX_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_leafs = -1;
ent->headnode = topnode;
break;
}
ent->leafnums[ent->num_leafs++] = clusters[i];
}
}
}
}
/*
===============================================================================
BOX TRACING
===============================================================================
*/
static void VBSP_FinalizeBrush(q2cbrush_t *brush)
{
vecV_t verts[256];
vec4_t planes[256];
int i, j;
ClearBounds(brush->absmins, brush->absmaxs);
for (i = 0; i < brush->numsides; i++)
{
VectorCopy(brush->brushside[i].plane->normal, planes[i]);
planes[i][3] = brush->brushside[i].plane->dist;
}
for (i = 0; i < brush->numsides; i++)
{
//most brushes are axial, which can save some a little loadtime
if (planes[i][0] == 1)
brush->absmaxs[0] = planes[i][3];
else if (planes[i][1] == 1)
brush->absmaxs[1] = planes[i][3];
else if (planes[i][2] == 1)
brush->absmaxs[2] = planes[i][3];
else if (planes[i][0] == -1)
brush->absmins[0] = -planes[i][3];
else if (planes[i][1] == -1)
brush->absmins[1] = -planes[i][3];
else if (planes[i][2] == -1)
brush->absmins[2] = -planes[i][3];
else
{
j = modfuncs->ClipPlaneToBrush(verts, countof(verts), planes, sizeof(planes[0]), brush->numsides, planes[i]);
while (j-- > 0)
AddPointToBounds(verts[j], brush->absmins, brush->absmaxs);
}
}
}
/*
===============================================================================
AREAPORTALS
===============================================================================
*/
static void FloodArea_r (vbspinfo_t *prv, size_t areaidx, int floodnum)
{
size_t i;
careaflood_t *flood = &prv->areaflood[areaidx];
if (flood->floodvalid == prv->floodvalid)
{
if (flood->floodnum == floodnum)
return;
Con_Printf ("FloodArea_r: reflooded\n");
return;
}
flood->floodnum = floodnum;
flood->floodvalid = prv->floodvalid;
{
carea_t *area = &prv->areas[areaidx];
q2dareaportal_t *p = &prv->areaportals[area->firstareaportal];
for (i=0 ; i<area->numareaportals ; i++, p++)
{
if (prv->portalopen[p->portalnum])
FloodArea_r (prv, p->otherarea, floodnum);
}
}
}
/*
====================
FloodAreaConnections
====================
*/
static void FloodAreaConnections (vbspinfo_t *prv)
{
size_t i;
int floodnum;
// all current floods are now invalid
prv->floodvalid++;
floodnum = 0;
// area 0 is not used
for (i=0 ; i<prv->numareas ; i++)
{
if (prv->areaflood[i].floodvalid == prv->floodvalid)
continue; // already flooded into
floodnum++;
FloodArea_r (prv, i, floodnum);
}
}
static void VBSP_SetAreaPortalState (model_t *mod, unsigned int portalnum, unsigned int area1, unsigned int area2, qboolean open)
{
vbspinfo_t *prv;
prv = (vbspinfo_t*)mod->meshinfo;
if (portalnum > prv->numareaportals)
return;
if (prv->portalopen[portalnum] == open)
return;
prv->portalopen[portalnum] = open;
FloodAreaConnections (prv);
}
static qboolean VBSP_AreasConnected (model_t *mod, unsigned int area1, unsigned int area2)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
if (map_noareas->value)
return true;
if (area1 == ~0 || area2 == ~0)
return area1 == area2;
if (area1 > prv->numareas || area2 > prv->numareas)
Host_Error ("area > numareas");
if (prv->areaflood[area1].floodnum == prv->areaflood[area2].floodnum)
return true;
return false;
}
/*
=================
CM_WriteAreaBits
Writes a length qbyte followed by a bit vector of all the areas
that area in the same flood as the area parameter
This is used by the client refreshes to cull visibility
=================
*/
static int VBSP_WriteAreaBits (model_t *mod, qbyte *buffer, int area, qboolean merge)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int i;
int floodnum;
int bytes;
int nullarea = 0;
bytes = (prv->numareas+7)>>3;
if (map_noareas->value || (area == nullarea && !merge))
{ // for debugging, send everything
if (!merge)
memset (buffer, 255, bytes);
}
else
{
if (!merge)
memset (buffer, 0, bytes);
floodnum = prv->areaflood[area].floodnum;
for (i=0 ; i<prv->numareas ; i++)
{
if (prv->areaflood[i].floodnum == floodnum)
buffer[i>>3] |= 1<<(i&7);
}
}
return bytes;
}
/*
===================
CM_WritePortalState
Returns a size+pointer to the data that needs to be written into a saved game.
===================
*/
static size_t VBSP_SaveAreaPortalBlob (model_t *mod, void **data)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
*data = prv->portalopen;
return sizeof(prv->portalopen);
}
/*
===================
CM_ReadPortalState
Reads the portal state from a savegame file
and recalculates the area connections
===================
*/
static size_t VBSP_LoadAreaPortalBlob (model_t *mod, void *ptr, size_t ptrsize)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
memcpy(prv->portalopen, ptr, min(ptrsize,sizeof(prv->portalopen)));
FloodAreaConnections (prv);
return sizeof(prv->portalopen);
}
/*
===============================================================================
PVS / PHS
===============================================================================
*/
/*
===================
CM_DecompressVis
===================
*/
static void VBSP_DecompressVis (model_t *mod, qbyte *in, qbyte *out, qboolean merge)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
int c;
qbyte *out_p;
int row;
row = (mod->numclusters+7)>>3;
out_p = out;
if (!in || !prv->numvisibility)
{ // no vis info, so make all visible
while (row)
{
*out_p++ = 0xff;
row--;
}
return;
}
if (merge)
{
do
{
if (*in)
{
*out_p++ |= *in++;
continue;
}
out_p += in[1];
in += 2;
} while (out_p - out < row);
}
else
{
do
{
if (*in)
{
*out_p++ = *in++;
continue;
}
c = in[1];
in += 2;
if ((out_p - out) + c > row)
{
c = row - (out_p - out);
Con_DPrintf ("warning: Vis decompression overrun\n");
}
while (c)
{
*out_p++ = 0;
c--;
}
} while (out_p - out < row);
}
}
static pvsbuffer_t pvsrow;
static pvsbuffer_t phsrow;
static qbyte *VBSP_ClusterPVS (model_t *mod, int cluster, pvsbuffer_t *buffer, pvsmerge_t merge)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
if (!buffer)
buffer = &pvsrow;
if (buffer->buffersize < mod->pvsbytes)
buffer->buffer = plugfuncs->Realloc(buffer->buffer, buffer->buffersize=mod->pvsbytes);
if (cluster == -1)
memset (buffer->buffer, 0, (mod->numclusters+7)>>3);
else
VBSP_DecompressVis (mod, ((qbyte*)prv->vis) + prv->vis->bitofs[cluster][DVIS_PVS], buffer->buffer, merge==PVM_MERGE);
return buffer->buffer;
}
static qbyte *VBSP_ClusterPHS (model_t *mod, int cluster, pvsbuffer_t *buffer)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
if (!buffer)
buffer = &phsrow;
if (buffer->buffersize < mod->pvsbytes)
buffer->buffer = plugfuncs->Realloc(buffer->buffer, buffer->buffersize=mod->pvsbytes);
if (cluster == -1)
memset (buffer->buffer, 0, (mod->numclusters+7)>>3);
else
VBSP_DecompressVis (mod, ((qbyte*)prv->vis) + prv->vis->bitofs[cluster][DVIS_PHS], buffer->buffer, false);
return buffer->buffer;
}
static unsigned int VBSP_FatPVS (model_t *mod, const vec3_t org, pvsbuffer_t *result, qboolean merge)
{
int leafs[64];
int i, j, count;
vec3_t mins, maxs;
for (i=0 ; i<3 ; i++)
{
mins[i] = org[i] - 8;
maxs[i] = org[i] + 8;
}
count = VBSP_BoxLeafnums (mod, mins, maxs, leafs, countof(leafs), NULL);
if (count < 1)
Sys_Errorf ("SV_Q2FatPVS: count < 1");
// convert leafs to clusters
for (i=0 ; i<count ; i++)
leafs[i] = VBSP_LeafCluster(mod, leafs[i]);
//grow the buffer if needed
if (result->buffersize < mod->pvsbytes)
result->buffer = plugfuncs->Realloc(result->buffer, result->buffersize=mod->pvsbytes);
if (count == 1 && leafs[0] == -1)
{ //if the only leaf is the outside then broadcast it.
memset(result->buffer, 0xff, mod->pvsbytes);
i = count;
}
else
{
i = 0;
if (!merge)
mod->funcs.ClusterPVS(mod, leafs[i++], result, PVM_REPLACE);
// or in all the other leaf bits
for ( ; i<count ; i++)
{
for (j=0 ; j<i ; j++)
if (leafs[i] == leafs[j])
break;
if (j != i)
continue; // already have the cluster we want
mod->funcs.ClusterPVS(mod, leafs[i], result, PVM_MERGE);
}
}
return mod->pvsbytes;
}
/*
=============
CM_HeadnodeVisible
Returns true if any leaf under headnode has a cluster that
is potentially visible
=============
*/
static qboolean VBSP_HeadnodeVisible (model_t *mod, int nodenum, const qbyte *visbits)
{
int leafnum;
int cluster;
mnode_t *node;
if (nodenum < 0)
{
leafnum = -1-nodenum;
cluster = mod->leafs[leafnum].cluster;
if (cluster == -1)
return false;
if (visbits[cluster>>3] & (1<<(cluster&7)))
return true;
return false;
}
node = &mod->nodes[nodenum];
if (VBSP_HeadnodeVisible(mod, node->childnum[0], visbits))
return true;
return VBSP_HeadnodeVisible(mod, node->childnum[1], visbits);
}
static qboolean VBSP_EdictInFatPVS(model_t *mod, const pvscache_t *ent, const qbyte *pvs, const int *areas)
{
int i,l;
int nullarea = 0;
if (areas)
{
for (i = 1; ; i++)
{
if (i > areas[0])
return false; //none of the camera's areas could see the entity
if (areas[i] == ent->areanum)
{
if (areas[i] != nullarea)
break;
//else entity is fully outside the world, invisible to all...
}
else if (VBSP_AreasConnected (mod, areas[i], ent->areanum))
break;
// doors can legally straddle two areas, so
// we may need to check another one
else if (ent->areanum2 != nullarea && VBSP_AreasConnected (mod, areas[i], ent->areanum2))
break;
}
}
if (ent->num_leafs == -1)
{ // too many leafs for individual check, go by headnode
if (!VBSP_HeadnodeVisible (mod, ent->headnode, pvs))
return false;
}
else
{ // check individual leafs
for (i=0 ; i < ent->num_leafs ; i++)
{
l = ent->leafnums[i];
if (pvs[l >> 3] & (1 << (l&7) ))
break;
}
if (i == ent->num_leafs)
return false; // not visible
}
return true;
}
/*
===============================================================================
Collision Stuff.
===============================================================================
*/
static void VBSP_BuildBIHSubmodel(model_t *mod, int submodel)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
cmodel_t *sub = &prv->cmodels[submodel];
struct bihleaf_s *bihleaf, *l;
size_t i;
bihleaf = l = plugfuncs->Malloc(sizeof(*bihleaf)*sub->num_brushes);
for (i = 0; i < sub->num_brushes; i++)
{
q2cbrush_t *b = &prv->brushes[sub->firstbrush+i];
l->type = BIH_BRUSH;
l->data.brush = b;
l->data.contents = b->contents;
VectorCopy(b->absmins, l->mins);
VectorCopy(b->absmaxs, l->maxs);
l++;
}
modfuncs->BIH_Build(mod, bihleaf, l-bihleaf);
plugfuncs->Free(bihleaf);
}
static void VBSP_BuildBIHMain(void *ctx, void *unusedp, size_t unuseda, size_t unusedb)
{ //NOTE: must be on main thread because we're waiting for submodels for their size.
model_t *mod = ctx;
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
cmodel_t *sub = &prv->cmodels[0];
struct bihleaf_s *bihleaf, *l;
size_t bihleafs, i;
bihleafs = sub->num_brushes;
for (i = 0; i < prv->numdisplacements; i++)
bihleafs += prv->displacements[i].numindexes/3;
for (i = 0; i < prv->numstaticprops; i++)
{
if (prv->staticprops[i].solid)
{
if (prv->staticprops[i].ent.model && prv->staticprops[i].ent.model->loadstate == MLS_NOTLOADED)
modfuncs->GetModel(prv->staticprops[i].ent.model->publicname, MLV_WARN); //we use threads, so these'll load in time.
bihleafs++;
}
}
bihleaf = l = plugfuncs->Malloc(sizeof(*bihleaf)*bihleafs);
//now we have enough storage, spit them out providing bounds info.
for (i = 0; i < sub->num_brushes; i++)
{
q2cbrush_t *b = &prv->brushes[sub->firstbrush+i];
l->type = BIH_BRUSH;
l->data.brush = b;
l->data.contents = b->contents;
VectorCopy(b->absmins, l->mins);
VectorCopy(b->absmaxs, l->maxs);
l++;
}
for (i = 0; i < prv->numdisplacements; i++)
{
dispinfo_t *d = &prv->displacements[i];
size_t j;
for (j = 0; j < d->numindexes; j+=3)
{
index_t *v = d->idx+j;
vec_t *v1 = d->xyz[v[0]], *v2 = d->xyz[v[1]], *v3 = d->xyz[v[2]];
l->type = BIH_TRIANGLE;
l->data.tri.xyz = d->xyz;
l->data.tri.indexes = v;
l->data.contents = d->contents;
VectorCopy(v1, l->mins);
VectorCopy(v1, l->maxs);
AddPointToBounds(v2, l->mins, l->maxs);
AddPointToBounds(v3, l->mins, l->maxs);
l++;
}
}
for (i = 0; i < prv->numstaticprops; i++)
{
if (!prv->staticprops[i].solid)
continue;
l->type = BIH_MODEL;
l->data.mesh.model = prv->staticprops[i].ent.model;
l->data.mesh.tr = &prv->staticprops[i].transform;
//*cry*
while (l->data.mesh.model->loadstate==MLS_LOADING)
threadfuncs->WaitForCompletion(l->data.mesh.model, &l->data.mesh.model->loadstate, MLS_LOADING);
if (!l->data.mesh.model || !l->data.mesh.model->funcs.NativeTrace || !l->data.mesh.model->funcs.NativeContents)
{
Con_Printf("%s has no collision info and must not be used as a solid static prop\n", l->data.mesh.model->name);
continue;
}
l->data.contents = ~0u; //yuck!
//a clever person could probably do a better job.
l->mins[0] = prv->staticprops[i].ent.origin[0] - l->data.mesh.model->radius;
l->mins[1] = prv->staticprops[i].ent.origin[1] - l->data.mesh.model->radius;
l->mins[2] = prv->staticprops[i].ent.origin[2] - l->data.mesh.model->radius;
l->maxs[0] = prv->staticprops[i].ent.origin[0] + l->data.mesh.model->radius;
l->maxs[1] = prv->staticprops[i].ent.origin[1] + l->data.mesh.model->radius;
l->maxs[2] = prv->staticprops[i].ent.origin[2] + l->data.mesh.model->radius;
l++;
}
modfuncs->BIH_Build(mod, bihleaf, l-bihleaf);
plugfuncs->Free(bihleaf);
mod->funcs.PointContents = VBSP_PointContents;
//and make sure we finished checksumming, too.
threadfuncs->WaitForCompletion(mod, &prv->summed, false);
}
/*
===============================================================================
Rendering stuff
===============================================================================
*/
#ifdef HAVE_CLIENT
static qboolean VBSP_CullBox (vec3_t mins, vec3_t maxs)
{
//this isn't very precise.
//checking each plane individually can be problematic
//if you have a large object behind the view, it can cross multiple planes, and be infront of each one at some point, yet should still be outside the view.
//this is quite noticable with terrain where the potential height of a section is essentually infinite.
//note that this is not a concern for spheres, just boxes.
int i;
for (i = 0; i < refdef->frustum_numplanes; i++)
if (BOX_ON_PLANE_SIDE (mins, maxs, &refdef->frustum[i]) == 2)
return true;
return false;
}
static void VBSP_RecursiveWorldNode (model_t *model, mnode_t *node)
{
int c, side;
mplane_t *plane;
msurface_t *surf, **mark;
mleaf_t *pleaf;
double dot;
int sidebit;
if (node->contents == FTECONTENTS_SOLID)
return; // solid
if (node->visframe != vbsp_nodesequence)
return;
if (VBSP_CullBox (node->minmaxs, node->minmaxs+3))
return;
// if a leaf node, draw stuff
if (node->contents != -1)
{
pleaf = (mleaf_t *)node;
// check for door connected areas
if (! (refdef->areabits[pleaf->area>>3] & (1<<(pleaf->area&7)) ) )
return; // not visible
c = pleaf->cluster;
if (c >= 0)
frustumvis[c>>3] |= 1<<(c&7);
mark = pleaf->firstmarksurface;
c = pleaf->nummarksurfaces;
if (c)
{
do
{
surf = *mark++;
if (surf->flags & SURF_OFFNODE)
{
if (surf->visframe != vbsp_surfsequence)
{ //only add once, it might be in multiple leafs.
surf->visframe = vbsp_surfsequence;
modfuncs->RenderDynamicLightmaps (surf);
surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
}
}
else
surf->visframe = vbsp_surfsequence;
} while (--c);
}
return;
}
// node is just a decision point, so go down the apropriate sides
// find which side of the node we are on
plane = node->plane;
switch (plane->type)
{
case PLANE_X:
dot = modelorg[0] - plane->dist;
break;
case PLANE_Y:
dot = modelorg[1] - plane->dist;
break;
case PLANE_Z:
dot = modelorg[2] - plane->dist;
break;
default:
dot = DotProduct (modelorg, plane->normal) - plane->dist;
break;
}
if (dot >= 0)
{
side = 0;
sidebit = 0;
}
else
{
side = 1;
sidebit = SURF_PLANEBACK;
}
// recurse down the children, front side first
VBSP_RecursiveWorldNode (model, node->children[side]);
// draw stuff
for ( c = node->numsurfaces, surf = model->surfaces + node->firstsurface; c ; c--, surf++)
{
if (surf->visframe != vbsp_surfsequence)
continue;
if ( (surf->flags & SURF_PLANEBACK) != sidebit )
continue; // wrong side
surf->visframe = 0;//vbsp_surfsequence;//-1;
modfuncs->RenderDynamicLightmaps (surf);
surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
}
// recurse down the back side
VBSP_RecursiveWorldNode (model, node->children[!side]);
}
static qbyte *VBSP_MarkLeaves (model_t *model, int clusters[2])
{
vbspinfo_t *prv = (vbspinfo_t*)model->meshinfo;
mnode_t *node;
int i;
int cluster;
mleaf_t *leaf;
qbyte *vis;
int portal = refdef->recurse;
if (refdef->forcevis)
{
vis = refdef->forcedvis;
prv->vcache.vis = NULL;
}
else if (portal || hl2_novis->ival || clusters[0] == -1 || !model->vis)
return NULL; //use some blind whole-model thing
else
{
vis = prv->vcache.vis;
if (prv->vcache.viewcluster[0] == clusters[0] && prv->vcache.viewcluster[1] == clusters[1] && vis)
return vis;
if (clusters[1] != clusters[0]) // may have to combine two clusters because of solid water boundaries
{
vis = VBSP_ClusterPVS (model, clusters[0], &prv->vcache.visbuf, PVM_REPLACE);
vis = VBSP_ClusterPVS (model, clusters[1], &prv->vcache.visbuf, PVM_MERGE);
}
else
vis = VBSP_ClusterPVS (model, clusters[0], &prv->vcache.visbuf, PVM_FAST);
prv->vcache.vis = vis;
prv->vcache.viewcluster[0] = clusters[0];
prv->vcache.viewcluster[1] = clusters[1];
}
vbsp_nodesequence++;
for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
{
cluster = leaf->cluster;
if (cluster == -1)
continue;
if (vis[cluster>>3] & (1<<(cluster&7)))
{
node = (mnode_t *)leaf;
do
{
if (node->visframe == vbsp_nodesequence)
break;
node->visframe = vbsp_nodesequence;
node = node->parent;
} while (node);
}
}
return vis;
}
static void VBSP_PrepareFrame(model_t *mod, refdef_t *r_refdef, int area, int clusters[2], pvsbuffer_t *vis, qbyte **entvis_out, qbyte **surfvis_out)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
qbyte *surfvis, *entvis;
refdef = r_refdef;
if (vis->buffersize < mod->pvsbytes)
vis->buffer = plugfuncs->Realloc(vis->buffer, vis->buffersize=mod->pvsbytes);
frustumvis = vis->buffer;
memset(frustumvis, 0, mod->pvsbytes);
if (!r_refdef->areabitsknown)
{ //generate the info each frame, as the gamecode didn't tell us what to use.
int leafnum = VBSP_PointLeafnum (mod, r_refdef->vieworg);
int clientarea = VBSP_LeafArea (mod, leafnum);
VBSP_WriteAreaBits(mod, r_refdef->areabits, clientarea, false);
r_refdef->areabitsknown = true;
}
entvis = surfvis = VBSP_MarkLeaves(mod, clusters);
VectorCopy (r_refdef->vieworg, modelorg);
if (!surfvis)
{
size_t i;
msurface_t *surf;
for (i = 0; i < mod->nummodelsurfaces; i++)
{
surf = &mod->surfaces[i];
modfuncs->RenderDynamicLightmaps (surf);
surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
}
}
else
{
size_t i;
dispinfo_t *disp;
msurface_t *surf;
int areas[2];
areas[0] = 1;
areas[1] = area;
vbsp_surfsequence++;
VBSP_RecursiveWorldNode (mod, mod->nodes);
for (i = 0; i < prv->numdisplacements; i++)
{
disp = &prv->displacements[i];
if (VBSP_EdictInFatPVS(mod, &disp->pvs, surfvis, areas))
{
surf = disp->surf;
modfuncs->RenderDynamicLightmaps (surf);
surf->sbatch->mesh[surf->sbatch->meshes++] = surf->mesh;
}
}
}
*surfvis_out = frustumvis;
*entvis_out = entvis;
if (prv->numstaticprops)
{
struct staticprop_s *sent;
entity_t *src, *ent;
float d;
size_t i;
vec3_t disp;
for (i = 0; i < prv->numstaticprops; i++)
{
sent = &prv->staticprops[i];
src = &sent->ent;
if (sent->fademaxdist)
{
VectorSubtract(refdef->vieworg, src->origin, disp);
d = VectorLength(disp);
if (d > sent->fademaxdist)
continue; //skip it.
d -= sent->fademindist;
d /= sent->fademaxdist-sent->fademindist;
if (d < 0)
d = 0;
}
else
d = 0;
if (!src->model || src->model->loadstate != MLS_LOADED)
{
if (src->model && src->model->loadstate == MLS_NOTLOADED)
modfuncs->GetModel(src->model->publicname, MLV_WARN); //we use threads, so these'll load in time.
continue;
}
/*if (!src->light_known)
{
vec3_t tmp;
VectorCopy(src->origin, tmp);
VectorCopy(sent->lightorg, src->origin);
R_CalcModelLighting(src, src->model); //bake and cache, now everything else is working.
VectorCopy(tmp, src->origin);
}*/
if (src->pvscache.num_leafs==-2)
{
vec3_t absmin, absmax;
float r = src->model->radius;
VectorSet(absmin, -r,-r,-r);
VectorSet(absmax, r,r,r);
VectorAdd(absmin, src->origin, absmin);
VectorAdd(absmax, src->origin, absmax);
VBSP_FindTouchedLeafs(mod, &src->pvscache, absmin, absmax);
}
ent = modfuncs->NewSceneEntity();
if (!ent)
return;
*ent = *src;
ent->framestate.g[FS_REG].frametime[0] = refdef->time;
ent->framestate.g[FS_REG].frametime[1] = refdef->time;
if (d)
{
ent->shaderRGBAf[3] *= 1-d;
ent->flags |= RF_TRANSLUCENT;
}
}
}
}
static void VBSP_InfoForPoint (struct model_s *mod, vec3_t pos, int *area, int *cluster, unsigned int *contentbits)
{
int leaf = VBSP_PointLeafnum_r (mod, pos, 0);
*area = VBSP_LeafArea(mod, leaf);
*cluster = VBSP_LeafCluster(mod, leaf);
*contentbits = VBSP_LeafContents(mod, leaf);
}
#ifdef RTLIGHTS
static int vbsp_shadowsequence;
static qbyte *shadowedpvs;
static model_t *shadowmodel;
static void VBSP_WalkShadows (dlight_t *dl, void (*callback)(msurface_t *surf), mnode_t *node)
{
int c, side;
mplane_t *plane;
msurface_t *surf, **mark;
mleaf_t *pleaf;
double dot;
float l, maxdist;
int j, s, t;
vec3_t impact;
struct vbsptexinfo_s *vtexinfo;
vbspinfo_t *prv;
if (node->shadowframe != vbsp_shadowsequence)
return;
//if light areabox is outside node, ignore node + children
for (c = 0; c < 3; c++)
{
if (dl->origin[c] + dl->radius < node->minmaxs[c])
return;
if (dl->origin[c] - dl->radius > node->minmaxs[3+c])
return;
}
// if a leaf node, draw stuff
if (node->contents != -1)
{
pleaf = (mleaf_t *)node;
if (pleaf->cluster >= 0)
shadowedpvs[pleaf->cluster>>3] |= 1<<(pleaf->cluster&7);
mark = pleaf->firstmarksurface;
c = pleaf->nummarksurfaces;
if (c)
{
do
{
surf = *mark++;
if (surf->flags & SURF_OFFNODE)
{
if (surf->shadowframe != vbsp_shadowsequence)
{ //if its not on a node then its probably not a nice flat surface, so don't bother trying to cull it in fancy ways that depend on its plane.
surf->shadowframe = vbsp_shadowsequence;
callback(surf);
}
}
else
surf->shadowframe = vbsp_shadowsequence;
} while (--c);
}
return;
}
// node is just a decision point, so go down the apropriate sides
// find which side of the node we are on
plane = node->plane;
switch (plane->type)
{
case PLANE_X:
dot = dl->origin[0] - plane->dist;
break;
case PLANE_Y:
dot = dl->origin[1] - plane->dist;
break;
case PLANE_Z:
dot = dl->origin[2] - plane->dist;
break;
default:
dot = DotProduct (dl->origin, plane->normal) - plane->dist;
break;
}
if (dot >= 0)
side = 0;
else
side = 1;
// recurse down the children, front side first
VBSP_WalkShadows (dl, callback, node->children[side]);
// draw stuff
c = node->numsurfaces;
if (c)
{
prv = shadowmodel->meshinfo;
surf = shadowmodel->surfaces + node->firstsurface;
maxdist = dl->radius*dl->radius;
for ( ; c ; c--, surf++)
{
if (surf->shadowframe != vbsp_shadowsequence)
continue;
if ((dot < 0) ^ !!(surf->flags & SURF_PLANEBACK))
continue; // wrong side
/* if (surf->flags & (SURF_DRAWALPHA | SURF_DRAWTILED))
{ // no shadows
continue;
}*/
//is the light on the right side?
if (surf->flags & SURF_PLANEBACK)
{//inverted normal.
if (-DotProduct(surf->plane->normal, dl->origin)+surf->plane->dist >= dl->radius)
continue;
}
else
{
if (DotProduct(surf->plane->normal, dl->origin)-surf->plane->dist >= dl->radius)
continue;
}
//Yeah, you can blame LordHavoc for this alternate code here.
for (j=0 ; j<3 ; j++)
impact[j] = dl->origin[j] - surf->plane->normal[j]*dot;
vtexinfo = &prv->texinfo[surf->texinfo-shadowmodel->texinfo];
// clamp center of light to corner and check brightness
l = DotProduct (impact, vtexinfo->lmvecs[0]) + vtexinfo->lmvecs[0][3] - surf->texturemins[0];
s = l;if (s < 0) s = 0;else if (s > surf->extents[0]) s = surf->extents[0];
s = (l - s)*surf->texinfo->vecscale[0];
l = DotProduct (impact, vtexinfo->lmvecs[1]) + vtexinfo->lmvecs[1][3] - surf->texturemins[1];
t = l;if (t < 0) t = 0;else if (t > surf->extents[1]) t = surf->extents[1];
t = (l - t)*surf->texinfo->vecscale[1];
// compare to minimum light
if ((s*s+t*t+dot*dot) < maxdist)
callback(surf);
}
}
// recurse down the back side
VBSP_WalkShadows (dl, callback, node->children[!side]);
}
static void VBSP_MarkShadows(model_t *model, dlight_t *dl, const qbyte *lvis)
{
mnode_t *node;
int i;
mleaf_t *leaf;
int cluster;
// if (!dl->die)
{
//static
//variation on mark leaves
for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
{
cluster = leaf->cluster;
if (cluster == -1)
continue;
if (lvis[cluster>>3] & (1<<(cluster&7)))
{
node = (mnode_t *)leaf;
do
{
if (node->shadowframe == vbsp_shadowsequence)
break;
node->shadowframe = vbsp_shadowsequence;
node = node->parent;
} while (node);
}
}
}
/* else
{
//dynamic lights will be discarded after this frame anyway, so only include leafs that are visible
//variation on mark leaves
for (i=0,leaf=model->leafs ; i<model->numleafs ; i++, leaf++)
{
cluster = leaf->cluster;
if (cluster == -1)
continue;
if (lvis[cluster>>3] & (1<<(cluster&7)))
{
node = (mnode_t *)leaf;
do
{
if (node->shadowframe == vbsp_shadowsequence)
break;
node->shadowframe = vbsp_shadowsequence;
node = node->parent;
} while (node);
}
}
}*/
}
void VBSP_GenerateShadowMesh(model_t *model, dlight_t *dl, const qbyte *lightvis, qbyte *litvis, void (*callback)(msurface_t *surf))
{
vbspinfo_t *prv = model->meshinfo;
dispinfo_t *disp;
int i;
//globals are evil
shadowmodel = model;
shadowedpvs = litvis; //this is an output
vbsp_shadowsequence++;
VBSP_MarkShadows(model, dl, lightvis);
VBSP_WalkShadows(dl, callback, model->nodes);
for (i = 0; i < prv->numdisplacements; i++)
{
disp = &prv->displacements[i];
if (VBSP_EdictInFatPVS(model, &disp->pvs, litvis, NULL))
{
callback(disp->surf);
}
}
}
#endif
static void VBSP_LoadLeafLight (model_t *mod, qbyte *mod_base, vlump_t *hdridx, vlump_t *ldridx, vlump_t *hdrvals, vlump_t *ldrvals, int version)
{
vbspinfo_t *prv = (vbspinfo_t*)mod->meshinfo;
vlump_t *lump_idx, *lump_vals;
struct leaflightpoint_s *point;
size_t i, j;
unsigned short *in;
qbyte *inpoint;
if (version < 20)
return; //nope. this info is in the leafs.
if (hdridx && hdrvals)
lump_idx = hdridx, lump_vals = hdrvals;
else if (ldridx && ldrvals)
lump_idx = ldridx, lump_vals = ldrvals;
else
return; //unsupported.
if (lump_vals->filelen%(7*4))
return;
if (lump_idx->filelen != mod->numleafs*sizeof(short)*2)
return; //erk?
//easy enough to load some of the data...
point = plugfuncs->GMalloc(&mod->memgroup, sizeof(*point)*(lump_vals->filelen/(7*4)));
inpoint = mod_base + lump_vals->fileofs;
for (i = 0; i < lump_vals->filelen/(7*4); i++)
{
for (j = 0; j < 6; j++, inpoint+=4)
{
float e = pow(2, (signed char)inpoint[3]);
point[i].rgb[j][0] = e * inpoint[0];
point[i].rgb[j][1] = e * inpoint[1];
point[i].rgb[j][2] = e * inpoint[2];
}
point[i].x = *inpoint++;
point[i].y = *inpoint++;
point[i].z = *inpoint++;
inpoint++;
}
prv->leaflight = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv->leaflight)*mod->numleafs);
in = (unsigned short*)(mod_base + lump_idx->fileofs);
for (i = 0; i < mod->numleafs; i++)
{
prv->leaflight[i].count = LittleShort(*in++);
prv->leaflight[i].point = point + (unsigned short)LittleShort(*in++);
}
}
static void VBSP_LightPointValues (struct model_s *model, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
vbspinfo_t *prv = (vbspinfo_t*)model->meshinfo;
int leafnum = VBSP_PointLeafnum(model,point);
mleaf_t *leaf = model->leafs+leafnum;
struct mleaflight_s *leaflight = prv->leaflight+leafnum;
struct leaflightpoint_s *best, *lp;
size_t i, j, d, bd=~0;
int xyz[3];
vec3_t diff[6];
float sig[6];
static cvar_t *srgbmag, *scale, *forceface;
if (!srgbmag) srgbmag = cvarfuncs->GetNVFDG("hl2_lt_srgb_mag","1", 0, "TEST", "TEST");
if (!scale) scale = cvarfuncs->GetNVFDG("hl2_lt_scale", "256", 0, "TEST", "TEST");
if (!forceface) forceface = cvarfuncs->GetNVFDG("hl2_lt_face", "-1", 0, "TEST", "TEST");
if (prv->leaflight && leaflight->count)
{
for (i = 0; i < 3; i++)
xyz[i] = 255*(point[i] - leaf->minmaxs[i]) / (leaf->minmaxs[3+i]-leaf->minmaxs[i]);
for (i = 0, best=lp = leaflight->point; i < leaflight->count; i++, lp++)
{
int m[3];
m[0] = xyz[0] - lp->x;
m[1] = xyz[1] - lp->y;
m[2] = xyz[2] - lp->z;
d = DotProduct(m,m);
if (bd > d)
{
bd = d;
best = lp;
}
}
VectorClear(res_ambient);
for (j = 0; j < 6; j++)
VectorAdd(res_ambient, best->rgb[j], res_ambient);
VectorScale(res_ambient, 1.0/6, res_ambient);
//try and figure out an average dir for the brightest direction
for (j = 0; j < 6; j++)
{
VectorSubtract(best->rgb[j], res_ambient, diff[j]);
sig[j] = VectorLength(diff[j]);
}
for (j = 0; j < 3; j++)
res_dir[j] = sig[j*2+1] - sig[j*2];
VectorNormalize(res_dir);
//figure out how much light there should be in that direction.
VectorCopy(res_ambient, res_diffuse);
for (j = 0; j < 3; j++)
{
if (res_dir[0]>=0)
VectorMA(res_diffuse, res_dir[0], diff[j*2+1], res_diffuse);
else
VectorMA(res_diffuse, -res_dir[0], diff[j*2+0], res_diffuse);
}
if (forceface->ival >= 0)
{
VectorCopy(best->rgb[forceface->ival], res_diffuse);
VectorCopy(best->rgb[forceface->ival], res_ambient);
VectorClear(res_dir);
res_dir[forceface->ival/3] = (forceface->ival&1)?-1:1;
}
if (srgbmag->value)
{
for (j = 0; j < 3; j++)
{
res_diffuse[j] = M_LinearToSRGB(res_diffuse[j], srgbmag->value)*scale->value;
res_ambient[j] = M_LinearToSRGB(res_ambient[j], srgbmag->value)*scale->value;
}
/*for (j = 0; j < 6; j++)
{
res_cube[j][0] = M_LinearToSRGB(best->rgb[j][0], srgbmag->value)*scale->value;
res_cube[j][1] = M_LinearToSRGB(best->rgb[j][1], srgbmag->value)*scale->value;
res_cube[j][2] = M_LinearToSRGB(best->rgb[j][2], srgbmag->value)*scale->value;
}*/
}
else
{
VectorScale(res_diffuse, scale->value, res_diffuse);
VectorScale(res_ambient, scale->value, res_ambient);
/*for (j = 0; j < 6; j++)
VectorScale(best->rgb[j], scale->value, res_cube[j]);*/
}
return;
}
VectorSet(res_dir, 0,0.707,0.707);
VectorSet(res_diffuse, 64,64,64);
VectorSet(res_ambient, 192,192,192);
}
#else
static void VBSP_LightPointValues (struct model_s *model, const vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
VectorSet(res_diffuse, 64,64,64);
VectorSet(res_ambient, 192,192,192);
VectorSet(res_dir, 0,0.707,0.707);
}
static void VBSP_LoadLeafLight (model_t *mod, qbyte *mod_base, vlump_t *hdridx, vlump_t *ldridx, vlump_t *hdrvals, vlump_t *ldrvals, int version)
{
}
#endif
static void VBSP_ComputedChecksum(void *ctx, void *data, size_t sum, size_t b)
{
model_t *mod = ctx;
vbspinfo_t *prv = mod->meshinfo;
mod->checksum = mod->checksum2 = sum;
prv->summed = true;
}
static void VBSP_ComputeChecksum(void *ctx, void *data, size_t length, size_t b)
{
unsigned int checksum = LittleLong (filefuncs->BlockChecksum(data, length));
threadfuncs->AddWork(WG_LOADER, VBSP_ComputedChecksum, ctx, NULL, checksum, 0);
}
static qboolean VBSP_LoadModel(model_t *mod, qbyte *mod_base, size_t filelen, char *loadname)
{
dvbspheader_t *srcheader = (void*)mod_base;
dvbspheader_t header;
vbspinfo_t *prv = mod->meshinfo;
size_t i;
qboolean noerrors = true;
#ifdef HAVE_CLIENT
qboolean haverenderer = qrenderer != QR_NONE;
#endif
VBSP_TranslateContentBits_Setup(prv);
threadfuncs->AddWork(WG_LOADER, VBSP_ComputeChecksum, mod, mod_base, filelen, 0);
mod->lightmaps.width = LMBLOCK_SIZE_MAX;
mod->lightmaps.height = LMBLOCK_SIZE_MAX;
mod->fromgame = fg_new;
mod->engineflags |= MDLF_NEEDOVERBRIGHT;
header.version = LittleLong(srcheader->version);
for (i=0 ; i<HL2_MAXLUMPS ; i++)
{
header.lumps[i].filelen = LittleLong (srcheader->lumps[i].filelen);
header.lumps[i].fileofs = LittleLong (srcheader->lumps[i].fileofs);
//fixme: truncate lumps if they go off the end
}
if (header.lumps[VLUMP_ZIPFILE].filelen)
modfuncs->LoadMapArchive(mod, mod_base+header.lumps[VLUMP_ZIPFILE].fileofs, header.lumps[VLUMP_ZIPFILE].filelen);
// load into heap
noerrors = noerrors && VBSP_LoadVertexes (mod, mod_base, &header.lumps[VLUMP_VERTEXES]);
noerrors = noerrors && VBSP_LoadEdges (mod, mod_base, &header.lumps[VLUMP_EDGES]);
noerrors = noerrors && VBSP_LoadSurfedges (mod, mod_base, &header.lumps[VLUMP_SURFEDGES]);
#ifdef HAVE_CLIENT
if (noerrors && haverenderer)
VBSP_LoadLighting (mod, mod_base, &header.lumps[VLUMP_LIGHTING_LDR], &header.lumps[VLUMP_LIGHTING_HDR]);
#endif
noerrors = noerrors && VBSP_LoadSurfaces (mod, mod_base, &header.lumps[VLUMP_TEXINFO]);
noerrors = noerrors && VBSP_LoadPlanes (mod, mod_base, &header.lumps[VLUMP_PLANES]);
noerrors = noerrors && VBSP_LoadTexInfo (mod, mod_base, header.lumps, loadname);
if (noerrors)
VBSP_LoadEntities (mod, mod_base, &header.lumps[VLUMP_ENTITIES]);
noerrors = noerrors && VBSP_LoadFaces (mod, mod_base, header.lumps, header.version);
noerrors = noerrors && VBSP_LoadDisplacements (mod, mod_base, header.lumps);
noerrors = noerrors && VBSP_LoadMarksurfaces (mod, mod_base, &header.lumps[VLUMP_LEAFFACES]);
noerrors = noerrors && VBSP_LoadVisibility (mod, mod_base, &header.lumps[VLUMP_VISIBILITY]);
noerrors = noerrors && VBSP_LoadBrushSides (mod, mod_base, &header.lumps[VLUMP_BRUSHSIDES]);
noerrors = noerrors && VBSP_LoadBrushes (mod, mod_base, &header.lumps[VLUMP_BRUSHES]);
noerrors = noerrors && VBSP_LoadLeafBrushes (mod, mod_base, &header.lumps[VLUMP_LEAFBRUSHES]);
noerrors = noerrors && VBSP_LoadLeafs (mod, mod_base, &header.lumps[VLUMP_LEAFS], header.version);
noerrors = noerrors && VBSP_LoadNodes (mod, mod_base, &header.lumps[VLUMP_NODES]);
noerrors = noerrors && VBSP_LoadSubmodels (mod, mod_base, &header.lumps[VLUMP_MODELS]);
noerrors = noerrors && VBSP_LoadAreas (mod, mod_base, &header.lumps[VLUMP_AREAS]);
noerrors = noerrors && VBSP_LoadAreaPortals (mod, mod_base, &header.lumps[VLUMP_AREAPORTALS], &header.lumps[VLUMP_AREAPORTALVERTS]);
#ifdef HAVE_CLIENT
if (noerrors && haverenderer)
VBSP_LoadLeafLight (mod, mod_base, &header.lumps[VLUMP_LEAFLIGHTI_HDR], &header.lumps[VLUMP_LEAFLIGHTI_LDR],
&header.lumps[VLUMP_LEAFLIGHTV_HDR], &header.lumps[VLUMP_LEAFLIGHTV_LDR], header.version);
#endif
noerrors = noerrors && VBSP_LoadGameLump (mod, mod_base, &header.lumps[VLUMP_GAMELUMP]);
if (!noerrors)
return false;
#ifdef HAVE_SERVER
mod->funcs.FatPVS = VBSP_FatPVS;
mod->funcs.EdictInFatPVS = VBSP_EdictInFatPVS;
mod->funcs.FindTouchedLeafs = VBSP_FindTouchedLeafs;
#endif
#ifdef HAVE_CLIENT
mod->funcs.LightPointValues = VBSP_LightPointValues;
// mod->funcs.StainNode = VBSP_StainNode;
// mod->funcs.MarkLights = VBSP_MarkLights;
mod->funcs.GenerateShadowMesh = VBSP_GenerateShadowMesh;
#endif
mod->funcs.ClusterPVS = VBSP_ClusterPVS;
mod->funcs.ClusterPHS = VBSP_ClusterPHS;
mod->funcs.ClusterForPoint = VBSP_PointCluster;
mod->funcs.SetAreaPortalState = VBSP_SetAreaPortalState;
mod->funcs.AreasConnected = VBSP_AreasConnected;
mod->funcs.LoadAreaPortalBlob = VBSP_LoadAreaPortalBlob;
mod->funcs.SaveAreaPortalBlob = VBSP_SaveAreaPortalBlob;
mod->funcs.PrepareFrame = VBSP_PrepareFrame;
mod->funcs.InfoForPoint = VBSP_InfoForPoint;
//displacements suck
for (i = 0; i < prv->numdisplacements; i++)
VBSP_FindTouchedLeafs(mod, &prv->displacements[i].pvs, prv->displacements[i].aamin, prv->displacements[i].aamax);
// if (noerrors)
// CM_CreatePatchesForLeafs (mod, prv);
return true;
}
/*
==================
CM_LoadMap
Loads in the map and all submodels
==================
*/
static qboolean VBSP_LoadMap (model_t *mod, void *filein, size_t filelen)
{
unsigned *buf;
int i;
dvbspheader_t header;
model_t *wmod = mod;
char loadname[32];
#ifdef HAVE_CLIENT
qbyte *facedata = NULL;
unsigned int facesize = 0;
#endif
vbspinfo_t *prv;
filefuncs->FileBase (mod->name, loadname, sizeof(loadname));
// free old stuff, just in case.
mod->meshinfo = prv = plugfuncs->GMalloc(&mod->memgroup, sizeof(*prv));
mod->type = mod_brush;
//
// load the file
//
buf = (unsigned *)filein;
if (!buf)
{
Con_Printf (CON_ERROR "Couldn't load %s\n", mod->name);
return false;
}
header = *(dvbspheader_t *)(buf);
header.magic = LittleLong(header.magic);
header.version = LittleLong(header.version);
ClearBounds(mod->mins, mod->maxs);
switch(header.version)
{
//case 17: //
case 18: //beta
case 19: //hl2,cs:s,hl2dm
case 20: //portal, l4d, hl2ep2
case 21: //cs:go, portal 2, l4d2
//case 22: //dota 2
//case 23: //dota 2
//case 27: //'contagion'
//case 29: //'titanfall'
if (!VBSP_LoadModel(mod, filein, filelen, loadname))
return false;
break;
default:
Con_Printf (CON_ERROR "VBSP with unknown version (%s: %i should be 18, 19, 20, or 21)\n"
, mod->name, header.version);
return false;
}
if (map_autoopenportals->value)
memset (prv->portalopen, 1, sizeof(prv->portalopen)); //open them all. Used for progs that havn't got a clue.
else
memset (prv->portalopen, 0, sizeof(prv->portalopen)); //make them start closed.
FloodAreaConnections (prv);
mod->nummodelsurfaces = mod->numsurfaces;
memset(&mod->batches, 0, sizeof(mod->batches));
mod->vbos = NULL;
mod->numsubmodels = VBSP_NumInlineModels(mod);
//in case anyone wants to know the typical player size...
VectorSet(mod->hulls[1].clip_mins, -16,-16,-36);
VectorSet(mod->hulls[1].clip_maxs, 16,16,36);
mod->hulls[0].firstclipnode = prv->cmodels[0].headnode-mod->nodes;
mod->rootnode = prv->cmodels[0].headnode;
mod->nummodelsurfaces = prv->cmodels[0].numsurfaces;
#ifdef HAVE_CLIENT
if (qrenderer != QR_NONE)
{
builddata_t *bd = plugfuncs->Malloc(sizeof(*bd) + facesize*mod->nummodelsurfaces);
bd->buildfunc = VBSP_BuildSurfMesh;
bd->paintlightmaps = true;
memcpy(bd+1, facedata + mod->firstmodelsurface*facesize, facesize*mod->nummodelsurfaces);
threadfuncs->AddWork(WG_MAIN, VBSP_GenerateMaterials, mod, bd, 0, 0);
}
#endif
for (i=1 ; i< mod->numsubmodels ; i++)
{
cmodel_t *bm;
char name[MAX_QPATH];
Q_snprintfz (name, sizeof(name), "*%i:%s", i, wmod->publicname);
mod = modfuncs->BeginSubmodelLoad(name);
*mod = *wmod;
mod->archive = NULL;
mod->entities_raw = NULL;
mod->submodelof = wmod;
Q_strncpyz(mod->publicname, name, sizeof(mod->publicname));
Q_snprintfz (mod->name, sizeof(mod->name), "*%i:%s", i, wmod->name);
memset(&mod->memgroup, 0, sizeof(mod->memgroup));
bm = VBSP_InlineModel (wmod, name);
mod->hulls[0].firstclipnode = -1; //no nodes,
if (bm->headleaf)
{
mod->leafs = bm->headleaf;
mod->nodes = NULL;
mod->hulls[0].firstclipnode = -1; //make it refer directly to the first leaf, for things that still use numbers.
mod->rootnode = (mnode_t*)bm->headleaf;
}
else
{
mod->leafs = wmod->leafs;
mod->nodes = wmod->nodes;
mod->hulls[0].firstclipnode = bm->headnode - mod->nodes; //determine the correct node index
mod->rootnode = bm->headnode;
}
mod->nummodelsurfaces = bm->numsurfaces;
mod->firstmodelsurface = bm->firstsurface;
VBSP_BuildBIHSubmodel(mod, i);
memset(&mod->batches, 0, sizeof(mod->batches));
mod->vbos = NULL;
VectorCopy (bm->maxs, mod->maxs);
VectorCopy (bm->mins, mod->mins);
#ifdef HAVE_CLIENT
mod->radius = RadiusFromBounds (mod->mins, mod->maxs);
if (qrenderer != QR_NONE)
{
builddata_t *bd = plugfuncs->Malloc(sizeof(*bd) + facesize*mod->nummodelsurfaces);
bd->buildfunc = VBSP_BuildSurfMesh;
bd->paintlightmaps = true;
memcpy(bd+1, facedata + mod->firstmodelsurface*facesize, facesize*mod->nummodelsurfaces);
threadfuncs->AddWork(WG_MAIN, VBSP_GenerateMaterials, mod, bd, i, 0);
}
#endif
modfuncs->EndSubmodelLoad(mod, MLS_LOADED);
}
//urgh, we need to wait for models to load in order to get their sizes. that requires being on the main thread and the caller will think we're loaded on completion so we can't safely pingpong it back before generating the bih tree
threadfuncs->AddWork(WG_MAIN, VBSP_BuildBIHMain, wmod, NULL, 0, 0);
return true;
}
qboolean VBSP_Init(void)
{
filefuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*filefuncs));
modfuncs = plugfuncs->GetEngineInterface(plugmodfuncs_name, sizeof(*modfuncs));
if (modfuncs && modfuncs->version < MODPLUGFUNCS_VERSION)
modfuncs = NULL;
threadfuncs = plugfuncs->GetEngineInterface(plugthreadfuncs_name, sizeof(*threadfuncs));
if (modfuncs && filefuncs && threadfuncs)
{
modfuncs->RegisterModelFormatMagic("Source (V)BSP", "VBSP",4, VBSP_LoadMap);
#define MAPOPTIONS "Map Cvar Options"
hl2_novis = cvarfuncs->GetNVFDG("r_novis", "0", 0, "Multiplier for how far displacements can move.", MAPOPTIONS);
hl2_displacement_scale = cvarfuncs->GetNVFDG("hl2_displacement_scale", "1", CVAR_RENDERERLATCH|CVAR_CHEAT, "Multiplier for how far displacements can move.", MAPOPTIONS);
hl2_favour_ldr = cvarfuncs->GetNVFDG("hl2_favour_ldr", "0", CVAR_RENDERERLATCH|CVAR_CHEAT, "Favour LDR data instead of HDR (when both are present).", MAPOPTIONS);
map_noareas = cvarfuncs->GetNVFDG("map_noareas", "0", 0, "Ignore areaportals.", MAPOPTIONS);
map_autoopenportals = cvarfuncs->GetNVFDG("map_autoopenportals", "0", CVAR_RENDERERLATCH, "When set to 1, force-opens all area portals. Normally these start closed and are opened by doors when they move, but this requires the gamecode to signal this.", MAPOPTIONS);
hl2_contents_remap = cvarfuncs->GetNVFDG("hl2_contents_remap",
"/*solid*/SOLID "
"/*window*/WINDOW "
"/*aux*/Q2AUX "
"/*grate*/CLIP " //would otherwise be LAVA
"/*slime*/SLIME "
"/*water*/WATER "
"/*mist*/Q2MIST "
"/*opaque*/7 "
"/*testfogvolume*/8 "
"/*??*/9 "
"/*??*/10 "
"/*team1*/11 "
"/*team2*/12 "
"/*ignorenodrawopaque*/13 "
"/*movable*/-1 " //would otherwise be LADDER
"/*areaportal*/Q2AREAPORTAL "
"/*playerclip*/PLAYERCLIP "
"/*monsterclip*/MONSTERCLIP "
"/*current_0*/Q2CURRENT_0 "
"/*current_90*/Q2CURRENT_90 "
"/*current_180*/Q2CURRENT_180 "
"/*current_270*/Q2CURRENT_270 "
"/*current_up*/Q2CURRENT_UP "
"/*current_down*/Q2CURRENT_DOWN "
"/*origin*/Q2ORIGIN "
"/*monster*/BODY "
"/*deadmonster*/CORPSE "
"/*detail*/DETAIL "
"/*translucent*/Q2TRANSLUCENT "
"/*ladder*/LADDER " //would otherwise be Q2LADDER
"/*hitbox*/30 "
"/*??*/SKY"
,CVAR_RENDERERLATCH, "Specifies a table for hl2->internal contentbits (one entry for each source bit).", MAPOPTIONS);
return true;
}
return false;
}
View git blame Copy permalink