/*
=================
ProcessFaces
=================
*/
static void ProcessFaces(bsp_t *bsp)
{
mface_t *s;
int i, j;
s = bsp->faces;
for (i = 0; i < bsp->numfaces; i++, s++) {
// set the drawing flags
if (s->texinfo->c.flags & SURF_SKY) {
continue;
}
if (s->texinfo->c.flags & (SURF_WARP | SURF_FLOWING)) {
s->drawflags |= DSURF_TURB;
for (j = 0; j < 2; j++) {
s->extents[j] = 16384;
s->texturemins[j] = -8192;
}
continue;
}
CalcSurfaceExtents(s);
}
}
/*
=================
Mod_LoadFaces
=================
*/
void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum;
int planenum, side;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_AllocName ( count*sizeof(*out), loadname);
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->flags = 0;
planenum = LittleShort(in->planenum);
side = LittleShort(in->side);
if (side)
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
if (i == -1)
out->samples = NULL;
else
out->samples = loadmodel->lightdata + i;
// set the drawing flags flag
if (!Q_strncmp(out->texinfo->texture->name,"sky",3)) // sky
{
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
#ifndef QUAKE2
GL_SubdivideSurface (out); // cut up polygon for warps
#endif
continue;
}
if (!Q_strncmp(out->texinfo->texture->name,"*",1)) // turbulent
{
out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
GL_SubdivideSurface (out); // cut up polygon for warps
continue;
}
}
}
/*
=================
Mod_LoadFaces
=================
*/
void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum;
int planenum, side;
int ti;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( count*sizeof(*out));
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
currentmodel = loadmodel;
GL_BeginBuildingLightmaps (loadmodel);
for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->flags = 0;
out->polys = NULL;
planenum = LittleShort(in->planenum);
side = LittleShort(in->side);
if (side)
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
ti = LittleShort (in->texinfo);
if (ti < 0 || ti >= loadmodel->numtexinfo)
ri.Sys_Error (ERR_DROP, "MOD_LoadBmodel: bad texinfo number");
out->texinfo = loadmodel->texinfo + ti;
CalcSurfaceExtents (out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
if (i == -1)
out->samples = NULL;
else
out->samples = loadmodel->lightdata + i;
// set the drawing flags
if (out->texinfo->flags & SURF_WARP)
{
out->flags |= SURF_DRAWTURB;
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
GL_SubdivideSurface (out); // cut up polygon for warps
}
// create lightmaps and polygons
if ( !(out->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP) ) )
GL_CreateSurfaceLightmap (out);
if (! (out->texinfo->flags & SURF_WARP) )
GL_BuildPolygonFromSurface(out);
}
GL_EndBuildingLightmaps ();
}
/*
=================
Mod_LoadFaces
=================
*/
static void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum;
int planenum, side;
in = (dface_t *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
SV_Error ("%s: funny lump size in %s", __thisfunc__, loadmodel->name);
count = l->filelen / sizeof(*in);
out = (msurface_t *) Hunk_AllocName (count * sizeof(*out), "faces");
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum = 0; surfnum < count; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->flags = 0;
planenum = LittleShort(in->planenum);
side = LittleShort(in->side);
if (side)
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (out);
// lighting info
for (i = 0; i < MAXLIGHTMAPS; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
if (i == -1)
{
out->samples = NULL;
}
else
{
out->samples = loadmodel->lightdata + i;
}
// set the drawing flags flag
if (!strncmp(out->texinfo->texture->name,"sky",3)) // sky
{
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
continue;
}
if (!strncmp(out->texinfo->texture->name, "*", 1)) // turbulent
{
out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
for (i = 0; i < 2; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
continue;
}
}
}
void dxModel::LoadFaces(lump_s *l)
{
typedef dxItemBuffer<dxVec2> dxVec2Buffer;
typedef dxItemBuffer<dxVec3> dxVec3Buffer;
dxVec3Buffer vertices_buffer(512 * 1024);
dxVec2Buffer txcoord1_buffer(512 * 1024);
dxVec2Buffer txcoord2_buffer(512 * 1024);
struct dface_s
{
short planenum;
short side;
int firstedge; // we must support > 64k edges
short numedges;
short texinfo;
// lighting info
byte styles[MAXLIGHTMAPS];
int lightofs; // start of [numstyles*surfsize] samples
};
//numsufvet = 0;
dface_s * in = (dface_s*)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
{
Sys_Error("bad face count");
}
int count = l->filelen / sizeof(*in);
surfaces = (msurface_s*)DX_MEM_ALLOC(sizeof(msurface_s) * count);
numsurfaces = count;
msurface_s * out = surfaces;
dxVec3 temp_vertices[32];
dxVec2 temp_txcoord1[32];
dxVec2 temp_txcoord2[32];
for (int i = 0; i < count; i++, in++, out++)
{
out->firstedge = Swap_LittleLong(in->firstedge);
out->numedges = Swap_LittleLong(in->numedges);
out->flags = SURF_NORMAL;
out->lightmap = NULL;
out->light_s = 0;
out->light_t = 0;
short planenum = Swap_LittleShort(in->planenum);
short side = Swap_LittleShort(in->side);
if (side)
{
out->flags |= SURF_PLANEBACK;
}
out->plane = planes + planenum;
short s = Swap_LittleShort(in->texinfo);
if (s >= numtexinfo)
{
Sys_Error("bad texinfo index");
}
out->texinfo = texinfo + s;
out->numverts = in->numedges;
out->vet_offset = vertices_buffer.GetCount();
int tex_w = 1;
int tex_h = 1;
float * v1 = out->texinfo->vecs[0];
float * v2 = out->texinfo->vecs[1];
if (out->texinfo->texture)
{
tex_w = out->texinfo->texture->width;
tex_h = out->texinfo->texture->height;
}
if (out->numverts > 32)
{
Sys_Error("too many surface vertices");
}
for (int j = 0; j < out->numverts; j++)
{
int e = surfedges[in->firstedge + j];
if (e >= 0)
{
temp_vertices[j] = vertices[edges[e].v[0]];
}
else
{
temp_vertices[j] = vertices[edges[-e].v[1]];
}
if (out->texinfo->texture)
{
float * vts = temp_vertices[j];
float s = v1[0] * vts[0] + v1[1] * vts[1] + v1[2] * vts[2] + v1[3];
float t = v2[0] * vts[0] + v2[1] * vts[1] + v2[2] * vts[2] + v2[3];
temp_txcoord1[j].x = s / tex_w;
temp_txcoord1[j].y = t / tex_h;
}
else
{
temp_txcoord1[j].x = 0;
temp_txcoord1[j].y = 0;
}
temp_txcoord2[j].x = 0;
temp_txcoord2[j].y = 0;
}
CalcSurfaceExtents(out);
//lighting info
for (int j = 0; j < MAXLIGHTMAPS; j++)
{
out->styles[j] = in->styles[j];
}
int lightofs = Swap_LittleLong(in->lightofs);
if (-1 == lightofs)
{
out->samples = NULL;
}
else
{
out->samples = lightdata + lightofs;
}
if (!out->texinfo->texture)
{
continue;
}
// set the drawing flags flag
if (!strncmp(out->texinfo->texture->name, "sky", 3))
{
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
goto SET_VERT_BUF;
}
if (!strncmp(out->texinfo->texture->name, "black", 5))
{
out->flags = SURF_NODRAW;
goto SET_VERT_BUF;
}
if (!strncmp(out->texinfo->texture->name, "hint", 4))
{
out->flags = SURF_NODRAW;
goto SET_VERT_BUF;
}
if (!strncmp(out->texinfo->texture->name, "aaatrigger", 10))
{
out->flags = SURF_NODRAW;
goto SET_VERT_BUF;
}
if (!strncmp(out->texinfo->texture->name, "*", 1)) // turbulent
{
out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
for (int k = 0; k < 2; k++)
{
out->extents[k] = 16384;
out->texturemins[k] = -8192;
}
//GL_SubdivideSurface (out); // cut up polygon for warps
goto SET_VERT_BUF;
}
//load lightmap
CreateSurfaceLightmap(out);
//set lightmap texture coordinate
for (int j = 0; j < out->numverts; j++)
{
float s = Vec3DotProduct(temp_vertices[j], out->texinfo->vecs[0]) + out->texinfo->vecs[0][3];
s -= out->texturemins[0];
s += out->light_s * 16;
s += 8;
s /= BLOCK_WIDTH * 16;
float t = Vec3DotProduct(temp_vertices[j], out->texinfo->vecs[1]) + out->texinfo->vecs[1][3];
t -= out->texturemins[1];
t += out->light_t * 16;
t += 8;
t /= BLOCK_HEIGHT * 16;
temp_txcoord2[j].x = s;
temp_txcoord2[j].y = t;
}
SET_VERT_BUF:
for (int j = 0; j < out->numverts; j++)
{
vertices_buffer.Add(temp_vertices[j]);
txcoord1_buffer.Add(temp_txcoord1[j]);
txcoord2_buffer.Add(temp_txcoord2[j]);
}
}
renderer.LoadLightmaps();
vertbuf_model = renderer.CreateVertexBufferVec3(vertices_buffer.GetBuffer(), vertices_buffer.GetCount());
texcoord1_model = renderer.CreateVertexBufferVec2(txcoord1_buffer.GetBuffer(), txcoord1_buffer.GetCount());
texcoord2_model = renderer.CreateVertexBufferVec2(txcoord2_buffer.GetBuffer(), txcoord2_buffer.GetCount());
}
/*
=================
Mod_LoadFaces
=================
*/
void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum;
int planenum, side;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
ri.Sys_Error (ERR_DROP,"MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
out = Hunk_Alloc ( (count+6)*sizeof(*out)); // extra for skybox
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
if (out->numedges < 3)
ri.Sys_Error (ERR_DROP,"Surface with %s edges", out->numedges);
out->flags = 0;
planenum = LittleShort(in->planenum);
side = LittleShort(in->side);
if (side)
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (out);
// lighting info is converted from 24 bit on disk to 8 bit
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
if (i == -1)
out->samples = NULL;
else
out->samples = loadmodel->lightdata + i/3;
// set the drawing flags flag
if (!out->texinfo->image)
continue;
if (out->texinfo->flags & SURF_SKY)
{
out->flags |= SURF_DRAWSKY;
continue;
}
if (out->texinfo->flags & SURF_WARP)
{
out->flags |= SURF_DRAWTURB;
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
continue;
}
//==============
//PGM
// this marks flowing surfaces as turbulent, but with the new
// SURF_FLOW flag.
if (out->texinfo->flags & SURF_FLOWING)
{
out->flags |= SURF_DRAWTURB | SURF_FLOW;
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
continue;
}
//PGM
//==============
}
}
/*
=================
Mod_LoadFaces
=================
*/
void Mod_LoadFaces (lump_t *l)
{
dface_t *in;
msurface_t *out;
int i, count, surfnum, planenum, side;
#ifdef BSP23TEST
int size = (mod_bspversion == 23) ? 24 : sizeof(dface_t);
in = (void *)(mod_base + l->fileofs);
if (l->filelen % size)
Host_Error ("Mod_LoadFaces: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / size;
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum=0 ; surfnum<count ; surfnum++, out++)
{
out->flags = 0;
planenum = LittleShort(in->planenum);
if ((side = LittleShort(in->side)))
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
if (mod_bspversion == 23)
{
out->firstedge = LittleLong(((dface23_t *)in)->firstedge);
out->numedges = LittleShort(((dface23_t *)in)->numedges);
out->texinfo = NULL; /******* FIXME *******/
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = ((dface23_t *)in)->styles[i];
i = LittleLong(((dface23_t *)in)->lightofs);
}
else
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (loadmodel, out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
}
#else
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadFaces: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->surfaces = out;
loadmodel->numsurfaces = count;
for (surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
{
out->firstedge = LittleLong(in->firstedge);
out->numedges = LittleShort(in->numedges);
out->flags = 0;
// out->visframe = 0; /************ JDH ************/
planenum = LittleShort(in->planenum);
if ((side = LittleShort(in->side)))
out->flags |= SURF_PLANEBACK;
out->plane = loadmodel->planes + planenum;
out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
CalcSurfaceExtents (loadmodel, out);
// lighting info
for (i=0 ; i<MAXLIGHTMAPS ; i++)
out->styles[i] = in->styles[i];
i = LittleLong(in->lightofs);
#endif
//out->samples = (i == -1) ? NULL : loadmodel->lightdata + i * 3;
out->samples = (i == -1) ? NULL : loadmodel->lightdata + i * loadmodel->lightdatadepth;
// set the drawing flags flag
if (ISSKYTEX(out->texinfo->texture->name)) // sky
{
out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
GL_SubdivideSurface (loadmodel, out); // cut up polygon for warps
}
else if (ISTURBTEX(out->texinfo->texture->name)) // turbulent
{
out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
for (i=0 ; i<2 ; i++)
{
out->extents[i] = 16384;
out->texturemins[i] = -8192;
}
GL_SubdivideSurface (loadmodel, out); // cut up polygon for warps
#ifdef HEXEN2_SUPPORT
if (hexen2)
{
if ((!Q_strncasecmp(out->texinfo->texture->name, "*rtex078",8)) ||
(!Q_strncasecmp(out->texinfo->texture->name, "*lowlight",9)))
out->flags |= SURF_TRANSLUCENT;
}
#endif
}
#ifdef BSP23TEST
in = (dface_t *) ((byte *) in + size);
#endif
}
}
#endif //#ifndef RQM_SV_ONLY
#ifdef BSP23TEST
typedef struct
{
int planenum;
short children[2]; // negative numbers are -(leafs+1), not nodes
float mins[3]; // for sphere culling
float maxs[3];
unsigned short firstface;
unsigned short numfaces; // counting both sides
} dnode23_t;
/*
=================
Mod_LoadNodes23
=================
*/
void Mod_LoadNodes23 (lump_t *l)
{
int i, j, count, p;
dnode23_t *in;
mnode_t *out;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error ("Mod_LoadNodes23: funny lump size in %s", loadmodel->name); // was Sys_Error
count = l->filelen / sizeof(*in);
out = Hunk_AllocName (count * sizeof(*out), mod_loadname);
loadmodel->nodes = out;
loadmodel->numnodes = count;
for (i=0 ; i<count ; i++, in++, out++)
{
for (j=0 ; j<3 ; j++)
{
out->minmaxs[j] = LittleFloat (in->mins[j]);
out->minmaxs[3+j] = LittleFloat (in->maxs[j]);
}
p = LittleLong(in->planenum);
out->plane = loadmodel->planes + p;
out->firstsurface = (unsigned short) LittleShort (in->firstface);
out->numsurfaces = (unsigned short) LittleShort (in->numfaces);
// out->visframe = 0; /****** JDH ******/
for (j=0 ; j<2 ; j++)
{
p = LittleShort (in->children[j]);
if (p >= 0)
out->children[j] = loadmodel->nodes + p;
else
out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
}
}
Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
}
