#include "quakedef.h"
#include "image.h"
#include "r_shadow.h"
-#include "winding.h"
+#include "polygon.h"
#include "curves.h"
+#include "wad.h"
-// note: model_shared.c sets up r_notexture, and r_surf_notexture
qbyte mod_q1bsp_novis[(MAX_MAP_LEAFS + 7)/ 8];
cvar_t r_miplightmaps = {CVAR_SAVE, "r_miplightmaps", "0"};
cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1"};
cvar_t r_nosurftextures = {0, "r_nosurftextures", "0"};
-cvar_t mod_q3bsp_curves_subdivide_level = {0, "mod_q3bsp_curves_subdivide_level", "2"};
+cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4"};
+cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1"};
+cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024"};
+cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536"};
+cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15"};
+cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1"};
+cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024"};
+cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225"};
cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1"};
-cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "0"};
+cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1"};
+cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0"};
+static void Mod_Q1BSP_Collision_Init (void);
void Mod_BrushInit(void)
{
// Cvar_RegisterVariable(&r_subdivide_size);
Cvar_RegisterVariable(&r_miplightmaps);
Cvar_RegisterVariable(&r_lightmaprgba);
Cvar_RegisterVariable(&r_nosurftextures);
- Cvar_RegisterVariable(&mod_q3bsp_curves_subdivide_level);
+ Cvar_RegisterVariable(&r_subdivisions_tolerance);
+ Cvar_RegisterVariable(&r_subdivisions_mintess);
+ Cvar_RegisterVariable(&r_subdivisions_maxtess);
+ Cvar_RegisterVariable(&r_subdivisions_maxvertices);
+ Cvar_RegisterVariable(&r_subdivisions_collision_tolerance);
+ Cvar_RegisterVariable(&r_subdivisions_collision_mintess);
+ Cvar_RegisterVariable(&r_subdivisions_collision_maxtess);
+ Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices);
Cvar_RegisterVariable(&mod_q3bsp_curves_collisions);
Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
+ Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
memset(mod_q1bsp_novis, 0xff, sizeof(mod_q1bsp_novis));
+ Mod_Q1BSP_Collision_Init();
}
static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
// LordHavoc: modified to start at first clip node,
// in other words: first node of the (sub)model
- node = model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode;
- while (node->contents == 0)
+ node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
+ while (node->plane)
node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
return (mleaf_t *)node;
leaf = Mod_Q1BSP_PointInLeaf(model, p);
if (leaf)
{
- i = min(outsize, (int)sizeof(leaf->ambient_sound_level));;
+ i = min(outsize, (int)sizeof(leaf->ambient_sound_level));
if (i)
{
memcpy(out, leaf->ambient_sound_level, i);
memset(out, 0, outsize);
}
-
-static int Mod_Q1BSP_BoxTouchingPVS_RecursiveBSPNode(const model_t *model, const mnode_t *node, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
+static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
{
- int leafnum;
-loc0:
- if (node->contents < 0)
- {
- // leaf
- if (node->contents == CONTENTS_SOLID)
- return false;
- leafnum = (mleaf_t *)node - model->brushq1.leafs - 1;
- return pvs[leafnum >> 3] & (1 << (leafnum & 7));
- }
-
- // node - recurse down the BSP tree
- switch (BoxOnPlaneSide(mins, maxs, node->plane))
- {
- case 1: // front
- node = node->children[0];
- goto loc0;
- case 2: // back
- node = node->children[1];
- goto loc0;
- default: // crossing
- if (node->children[0]->contents != CONTENTS_SOLID)
- if (Mod_Q1BSP_BoxTouchingPVS_RecursiveBSPNode(model, node->children[0], pvs, mins, maxs))
+ int clusterindex, side, nodestackindex = 0;
+ mnode_t *node, *nodestack[1024];
+ if (!model->brush.num_pvsclusters)
+ return true;
+ node = model->brush.data_nodes;
+ for (;;)
+ {
+ if (node->plane)
+ {
+ // node - recurse down the BSP tree
+ side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ if (side < 2)
+ {
+ // box is on one side of plane, take that path
+ node = node->children[side];
+ }
+ else
+ {
+ // box crosses plane, take one path and remember the other
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ }
+ }
+ else
+ {
+ // leaf - check cluster bit
+ clusterindex = ((mleaf_t *)node)->clusterindex;
+ if (CHECKPVSBIT(pvs, clusterindex))
+ {
+ // it is visible, return immediately with the news
return true;
- node = node->children[1];
- goto loc0;
+ }
+ else
+ {
+ // nothing to see here, try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
+ }
+ }
}
- // never reached
+ // it is not visible
return false;
}
-int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
-{
- return Mod_Q1BSP_BoxTouchingPVS_RecursiveBSPNode(model, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode, pvs, mins, maxs);
-}
-
-/*
-static int Mod_Q1BSP_PointContents(model_t *model, const vec3_t p)
+static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const qbyte *visibleleafs, const vec3_t mins, const vec3_t maxs)
{
- mnode_t *node;
-
- if (model == NULL)
- return CONTENTS_EMPTY;
-
- Mod_CheckLoaded(model);
-
- // LordHavoc: modified to start at first clip node,
- // in other words: first node of the (sub)model
- node = model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode;
- while (node->contents == 0)
- node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
-
- return ((mleaf_t *)node)->contents;
+ int side, nodestackindex = 0;
+ mnode_t *node, *nodestack[1024];
+ node = model->brush.data_nodes;
+ for (;;)
+ {
+ if (node->plane)
+ {
+ // node - recurse down the BSP tree
+ side = BoxOnPlaneSide(mins, maxs, node->plane) - 1;
+ if (side < 2)
+ {
+ // box is on one side of plane, take that path
+ node = node->children[side];
+ }
+ else
+ {
+ // box crosses plane, take one path and remember the other
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
+ node = node->children[1];
+ }
+ }
+ else
+ {
+ // leaf - check if it is visible
+ if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
+ {
+ // it is visible, return immediately with the news
+ return true;
+ }
+ else
+ {
+ // nothing to see here, try another path we didn't take earlier
+ if (nodestackindex == 0)
+ break;
+ node = nodestack[--nodestackindex];
+ }
+ }
+ }
+ // it is not visible
+ return false;
}
-*/
typedef struct findnonsolidlocationinfo_s
{
}
findnonsolidlocationinfo_t;
-#if 0
-extern cvar_t samelevel;
-#endif
static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf)
{
- int i, surfnum, k, *tri, *mark;
+ int i, surfacenum, k, *tri, *mark;
float dist, f, vert[3][3], edge[3][3], facenormal[3], edgenormal[3][3], point[3];
-#if 0
- float surfnormal[3];
-#endif
- msurface_t *surf;
- for (surfnum = 0, mark = leaf->firstmarksurface;surfnum < leaf->nummarksurfaces;surfnum++, mark++)
+ msurface_t *surface;
+ for (surfacenum = 0, mark = leaf->firstleafsurface;surfacenum < leaf->numleafsurfaces;surfacenum++, mark++)
{
- surf = info->model->brushq1.surfaces + *mark;
- if (surf->flags & SURF_SOLIDCLIP)
+ surface = info->model->brush.data_surfaces + *mark;
+ if (surface->texture->supercontents & SUPERCONTENTS_SOLID)
{
-#if 0
- VectorCopy(surf->plane->normal, surfnormal);
- if (surf->flags & SURF_PLANEBACK)
- VectorNegate(surfnormal, surfnormal);
-#endif
- for (k = 0;k < surf->mesh.num_triangles;k++)
+ for (k = 0;k < surface->mesh.num_triangles;k++)
{
- tri = surf->mesh.data_element3i + k * 3;
- VectorCopy((surf->mesh.data_vertex3f + tri[0] * 3), vert[0]);
- VectorCopy((surf->mesh.data_vertex3f + tri[1] * 3), vert[1]);
- VectorCopy((surf->mesh.data_vertex3f + tri[2] * 3), vert[2]);
+ tri = surface->mesh.data_element3i + k * 3;
+ VectorCopy((surface->mesh.data_vertex3f + tri[0] * 3), vert[0]);
+ VectorCopy((surface->mesh.data_vertex3f + tri[1] * 3), vert[1]);
+ VectorCopy((surface->mesh.data_vertex3f + tri[2] * 3), vert[2]);
VectorSubtract(vert[1], vert[0], edge[0]);
VectorSubtract(vert[2], vert[1], edge[1]);
CrossProduct(edge[1], edge[0], facenormal);
if (facenormal[0] || facenormal[1] || facenormal[2])
{
VectorNormalize(facenormal);
-#if 0
- if (VectorDistance(facenormal, surfnormal) > 0.01f)
- Con_Printf("a2! %f %f %f != %f %f %f\n", facenormal[0], facenormal[1], facenormal[2], surfnormal[0], surfnormal[1], surfnormal[2]);
-#endif
f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
if (f <= info->bestdist && f >= -info->bestdist)
{
CrossProduct(facenormal, edge[0], edgenormal[0]);
CrossProduct(facenormal, edge[1], edgenormal[1]);
CrossProduct(facenormal, edge[2], edgenormal[2]);
-#if 0
- if (samelevel.integer & 1)
- VectorNegate(edgenormal[0], edgenormal[0]);
- if (samelevel.integer & 2)
- VectorNegate(edgenormal[1], edgenormal[1]);
- if (samelevel.integer & 4)
- VectorNegate(edgenormal[2], edgenormal[2]);
- for (i = 0;i < 3;i++)
- if (DotProduct(vert[0], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
- || DotProduct(vert[1], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f
- || DotProduct(vert[2], edgenormal[i]) > DotProduct(vert[i], edgenormal[i]) + 0.1f)
- Con_Printf("a! %i : %f %f %f (%f %f %f)\n", i, edgenormal[i][0], edgenormal[i][1], edgenormal[i][2], facenormal[0], facenormal[1], facenormal[2]);
-#endif
// face distance
if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
&& DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, mnode_t *node)
{
- if (node->contents)
- {
- if (((mleaf_t *)node)->nummarksurfaces)
- Mod_Q1BSP_FindNonSolidLocation_r_Leaf(info, (mleaf_t *)node);
- }
- else
+ if (node->plane)
{
float f = PlaneDiff(info->center, node->plane);
if (f >= -info->bestdist)
if (f <= info->bestdist)
Mod_Q1BSP_FindNonSolidLocation_r(info, node->children[1]);
}
+ else
+ {
+ if (((mleaf_t *)node)->numleafsurfaces)
+ Mod_Q1BSP_FindNonSolidLocation_r_Leaf(info, (mleaf_t *)node);
+ }
}
static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius)
{
VectorClear(info.nudge);
info.bestdist = radius;
- Mod_Q1BSP_FindNonSolidLocation_r(&info, model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode);
+ Mod_Q1BSP_FindNonSolidLocation_r(&info, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode);
VectorAdd(info.center, info.nudge, info.center);
}
while (info.bestdist < radius && ++i < 10);
// if the first leaf is solid, set startsolid
if (t->trace->allsolid)
t->trace->startsolid = true;
-#ifdef COLLISIONPARANOID
- Con_Printf("S");
+#if COLLISIONPARANOID >= 3
+ Con_Print("S");
#endif
return HULLCHECKSTATE_SOLID;
}
else
{
t->trace->allsolid = false;
-#ifdef COLLISIONPARANOID
- Con_Printf("E");
+#if COLLISIONPARANOID >= 3
+ Con_Print("E");
#endif
return HULLCHECKSTATE_EMPTY;
}
{
if (t2 < 0)
{
-#ifdef COLLISIONPARANOID
- Con_Printf("<");
+#if COLLISIONPARANOID >= 3
+ Con_Print("<");
#endif
num = node->children[1];
goto loc0;
{
if (t2 >= 0)
{
-#ifdef COLLISIONPARANOID
- Con_Printf(">");
+#if COLLISIONPARANOID >= 3
+ Con_Print(">");
#endif
num = node->children[0];
goto loc0;
// the line intersects, find intersection point
// LordHavoc: this uses the original trace for maximum accuracy
-#ifdef COLLISIONPARANOID
- Con_Printf("M");
+#if COLLISIONPARANOID >= 3
+ Con_Print("M");
#endif
if (plane->type < 3)
{
VectorCopy (plane->normal, t->trace->plane.normal);
}
- // bias away from surface a bit
- t1 = DotProduct(t->trace->plane.normal, t->start) - (t->trace->plane.dist + DIST_EPSILON);
- t2 = DotProduct(t->trace->plane.normal, t->end) - (t->trace->plane.dist + DIST_EPSILON);
-
+ // calculate the true fraction
+ t1 = DotProduct(t->trace->plane.normal, t->start) - t->trace->plane.dist;
+ t2 = DotProduct(t->trace->plane.normal, t->end) - t->trace->plane.dist;
midf = t1 / (t1 - t2);
- t->trace->fraction = bound(0.0f, midf, 1.0);
+ t->trace->realfraction = bound(0, midf, 1);
+
+ // calculate the return fraction which is nudged off the surface a bit
+ midf = (t1 - DIST_EPSILON) / (t1 - t2);
+ t->trace->fraction = bound(0, midf, 1);
-#ifdef COLLISIONPARANOID
- Con_Printf("D");
+#if COLLISIONPARANOID >= 3
+ Con_Print("D");
#endif
return HULLCHECKSTATE_DONE;
}
-#ifndef COLLISIONPARANOID
+#if COLLISIONPARANOID < 2
static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
{
while (num >= 0)
rhc.trace = trace;
rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
rhc.trace->fraction = 1;
+ rhc.trace->realfraction = 1;
rhc.trace->allsolid = true;
VectorSubtract(boxstartmaxs, boxstartmins, boxsize);
if (boxsize[0] < 3)
VectorSubtract(boxstartmins, rhc.hull->clip_mins, rhc.start);
VectorSubtract(boxendmins, rhc.hull->clip_mins, rhc.end);
VectorSubtract(rhc.end, rhc.start, rhc.dist);
-#ifdef COLLISIONPARANOID
+#if COLLISIONPARANOID >= 2
Con_Printf("t(%f %f %f,%f %f %f,%i %f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2], rhc.hull - model->brushq1.hulls, rhc.hull->clip_mins[0], rhc.hull->clip_mins[1], rhc.hull->clip_mins[2]);
Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
- Con_Printf("\n");
+ Con_Print("\n");
#else
if (DotProduct(rhc.dist, rhc.dist))
Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
#endif
}
+static hull_t box_hull;
+static dclipnode_t box_clipnodes[6];
+static mplane_t box_planes[6];
+
+static void Mod_Q1BSP_Collision_Init (void)
+{
+ int i;
+ int side;
+
+ //Set up the planes and clipnodes so that the six floats of a bounding box
+ //can just be stored out and get a proper hull_t structure.
+
+ box_hull.clipnodes = box_clipnodes;
+ box_hull.planes = box_planes;
+ box_hull.firstclipnode = 0;
+ box_hull.lastclipnode = 5;
+
+ for (i = 0;i < 6;i++)
+ {
+ box_clipnodes[i].planenum = i;
+
+ side = i&1;
+
+ box_clipnodes[i].children[side] = CONTENTS_EMPTY;
+ if (i != 5)
+ box_clipnodes[i].children[side^1] = i + 1;
+ else
+ box_clipnodes[i].children[side^1] = CONTENTS_SOLID;
+
+ box_planes[i].type = i>>1;
+ box_planes[i].normal[i>>1] = 1;
+ }
+}
+
+void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents)
+{
+#if 1
+ colbrushf_t cbox;
+ colplanef_t cbox_planes[6];
+ cbox.supercontents = boxsupercontents;
+ cbox.numplanes = 6;
+ cbox.numpoints = 0;
+ cbox.numtriangles = 0;
+ cbox.planes = cbox_planes;
+ cbox.points = NULL;
+ cbox.elements = NULL;
+ cbox.markframe = 0;
+ cbox.mins[0] = 0;
+ cbox.mins[1] = 0;
+ cbox.mins[2] = 0;
+ cbox.maxs[0] = 0;
+ cbox.maxs[1] = 0;
+ cbox.maxs[2] = 0;
+ cbox_planes[0].normal[0] = 1;cbox_planes[0].normal[1] = 0;cbox_planes[0].normal[2] = 0;cbox_planes[0].dist = cmaxs[0] - mins[0];
+ cbox_planes[1].normal[0] = -1;cbox_planes[1].normal[1] = 0;cbox_planes[1].normal[2] = 0;cbox_planes[1].dist = maxs[0] - cmins[0];
+ cbox_planes[2].normal[0] = 0;cbox_planes[2].normal[1] = 1;cbox_planes[2].normal[2] = 0;cbox_planes[2].dist = cmaxs[1] - mins[1];
+ cbox_planes[3].normal[0] = 0;cbox_planes[3].normal[1] = -1;cbox_planes[3].normal[2] = 0;cbox_planes[3].dist = maxs[1] - cmins[1];
+ cbox_planes[4].normal[0] = 0;cbox_planes[4].normal[1] = 0;cbox_planes[4].normal[2] = 1;cbox_planes[4].dist = cmaxs[2] - mins[2];
+ cbox_planes[5].normal[0] = 0;cbox_planes[5].normal[1] = 0;cbox_planes[5].normal[2] = -1;cbox_planes[5].dist = maxs[2] - cmins[2];
+ memset(trace, 0, sizeof(trace_t));
+ trace->hitsupercontentsmask = hitsupercontentsmask;
+ trace->fraction = 1;
+ trace->realfraction = 1;
+ Collision_TraceLineBrushFloat(trace, start, end, &cbox, &cbox);
+#else
+ RecursiveHullCheckTraceInfo_t rhc;
+ // fill in a default trace
+ memset(&rhc, 0, sizeof(rhc));
+ memset(trace, 0, sizeof(trace_t));
+ //To keep everything totally uniform, bounding boxes are turned into small
+ //BSP trees instead of being compared directly.
+ // create a temp hull from bounding box sizes
+ box_planes[0].dist = cmaxs[0] - mins[0];
+ box_planes[1].dist = cmins[0] - maxs[0];
+ box_planes[2].dist = cmaxs[1] - mins[1];
+ box_planes[3].dist = cmins[1] - maxs[1];
+ box_planes[4].dist = cmaxs[2] - mins[2];
+ box_planes[5].dist = cmins[2] - maxs[2];
+#if COLLISIONPARANOID >= 3
+ Con_Printf("box_planes %f:%f %f:%f %f:%f\ncbox %f %f %f:%f %f %f\nbox %f %f %f:%f %f %f\n", box_planes[0].dist, box_planes[1].dist, box_planes[2].dist, box_planes[3].dist, box_planes[4].dist, box_planes[5].dist, cmins[0], cmins[1], cmins[2], cmaxs[0], cmaxs[1], cmaxs[2], mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
+#endif
+ // trace a line through the generated clipping hull
+ //rhc.boxsupercontents = boxsupercontents;
+ rhc.hull = &box_hull;
+ rhc.trace = trace;
+ rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
+ rhc.trace->fraction = 1;
+ rhc.trace->realfraction = 1;
+ rhc.trace->allsolid = true;
+ VectorCopy(start, rhc.start);
+ VectorCopy(end, rhc.end);
+ VectorSubtract(rhc.end, rhc.start, rhc.dist);
+ Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
+ //VectorMA(rhc.start, rhc.trace->fraction, rhc.dist, rhc.trace->endpos);
+ if (rhc.trace->startsupercontents)
+ rhc.trace->startsupercontents = boxsupercontents;
+#endif
+}
+
static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
{
int side, distz = endz - startz;
float mid;
loc0:
- if (node->contents < 0)
+ if (!node->plane)
return false; // didn't hit anything
switch (node->plane->type)
}
// go down front side
- if (node->children[side]->contents >= 0 && Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid))
+ if (node->children[side]->plane && Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid))
return true; // hit something
else
{
if (node->numsurfaces)
{
int i, ds, dt;
- msurface_t *surf;
+ msurface_t *surface;
- surf = cl.worldmodel->brushq1.surfaces + node->firstsurface;
- for (i = 0;i < node->numsurfaces;i++, surf++)
+ surface = r_refdef.worldmodel->brush.data_surfaces + node->firstsurface;
+ for (i = 0;i < node->numsurfaces;i++, surface++)
{
- if (!(surf->flags & SURF_LIGHTMAP))
+ if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->samples)
continue; // no lightmaps
- ds = (int) (x * surf->texinfo->vecs[0][0] + y * surf->texinfo->vecs[0][1] + mid * surf->texinfo->vecs[0][2] + surf->texinfo->vecs[0][3]);
- dt = (int) (x * surf->texinfo->vecs[1][0] + y * surf->texinfo->vecs[1][1] + mid * surf->texinfo->vecs[1][2] + surf->texinfo->vecs[1][3]);
-
- if (ds < surf->texturemins[0] || dt < surf->texturemins[1])
- continue;
-
- ds -= surf->texturemins[0];
- dt -= surf->texturemins[1];
-
- if (ds > surf->extents[0] || dt > surf->extents[1])
- continue;
+ ds = (int) (x * surface->texinfo->vecs[0][0] + y * surface->texinfo->vecs[0][1] + mid * surface->texinfo->vecs[0][2] + surface->texinfo->vecs[0][3]) - surface->texturemins[0];
+ dt = (int) (x * surface->texinfo->vecs[1][0] + y * surface->texinfo->vecs[1][1] + mid * surface->texinfo->vecs[1][2] + surface->texinfo->vecs[1][3]) - surface->texturemins[1];
- if (surf->samples)
+ if (ds >= 0 && ds < surface->extents[0] && dt >= 0 && dt < surface->extents[1])
{
qbyte *lightmap;
- int maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
- line3 = ((surf->extents[0]>>4)+1)*3;
- size3 = ((surf->extents[0]>>4)+1) * ((surf->extents[1]>>4)+1)*3; // LordHavoc: *3 for colored lighting
+ int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
+ lmwidth = ((surface->extents[0]>>4)+1);
+ lmheight = ((surface->extents[1]>>4)+1);
+ line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting
+ size3 = lmwidth * lmheight * 3; // LordHavoc: *3 for colored lighting
- lightmap = surf->samples + ((dt>>4) * ((surf->extents[0]>>4)+1) + (ds>>4))*3; // LordHavoc: *3 for color
+ lightmap = surface->samples + ((dt>>4) * lmwidth + (ds>>4))*3; // LordHavoc: *3 for colored lighting
- for (maps = 0;maps < MAXLIGHTMAPS && surf->styles[maps] != 255;maps++)
+ for (maps = 0;maps < MAXLIGHTMAPS && surface->styles[maps] != 255;maps++)
{
- scale = d_lightstylevalue[surf->styles[maps]];
+ scale = d_lightstylevalue[surface->styles[maps]];
r00 += lightmap[ 0] * scale;g00 += lightmap[ 1] * scale;b00 += lightmap[ 2] * scale;
r01 += lightmap[ 3] * scale;g01 += lightmap[ 4] * scale;b01 += lightmap[ 5] * scale;
r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
ambientcolor[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
ambientcolor[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
ambientcolor[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
+ return true; // success
}
- return true; // success
}
}
void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
{
- Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, cl.worldmodel->brushq1.nodes + cl.worldmodel->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
+ Mod_Q1BSP_LightPoint_RecursiveBSPNode(ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2], p[2] - 65536);
}
static void Mod_Q1BSP_DecompressVis(const qbyte *in, const qbyte *inend, qbyte *out, qbyte *outend)
{
int c;
+ qbyte *outstart = out;
while (out < outend)
{
if (in == inend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\"\n", loadmodel->name);
+ Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
c = *in++;
{
if (in == inend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\"\n", loadmodel->name);
+ Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
for (c = *in++;c > 0;c--)
{
if (out == outend)
{
- Con_DPrintf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\"\n", loadmodel->name);
+ Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, out - outstart, outend - outstart);
return;
}
*out++ = 0;
}
}
+/*
+=============
+R_Q1BSP_LoadSplitSky
+
+A sky texture is 256*128, with the right side being a masked overlay
+==============
+*/
+void R_Q1BSP_LoadSplitSky (qbyte *src, int width, int height, int bytesperpixel)
+{
+ int i, j;
+ unsigned solidpixels[128*128], alphapixels[128*128];
+
+ // if sky isn't the right size, just use it as a solid layer
+ if (width != 256 || height != 128)
+ {
+ loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
+ loadmodel->brush.alphaskytexture = NULL;;
+ return;
+ }
+
+ if (bytesperpixel == 4)
+ {
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128];
+ alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j];
+ }
+ }
+ }
+ else
+ {
+ // make an average value for the back to avoid
+ // a fringe on the top level
+ int p, r, g, b;
+ union
+ {
+ unsigned int i;
+ unsigned char b[4];
+ }
+ rgba;
+ r = g = b = 0;
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ rgba.i = palette_complete[src[i*256 + j + 128]];
+ r += rgba.b[0];
+ g += rgba.b[1];
+ b += rgba.b[2];
+ }
+ }
+ rgba.b[0] = r/(128*128);
+ rgba.b[1] = g/(128*128);
+ rgba.b[2] = b/(128*128);
+ rgba.b[3] = 0;
+ for (i = 0;i < 128;i++)
+ {
+ for (j = 0;j < 128;j++)
+ {
+ solidpixels[(i*128) + j] = palette_complete[src[i*256 + j + 128]];
+ alphapixels[(i*128) + j] = (p = src[i*256 + j]) ? palette_complete[p] : rgba.i;
+ }
+ }
+ }
+
+ loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (qbyte *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+ loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (qbyte *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+}
+
static void Mod_Q1BSP_LoadTextures(lump_t *l)
{
int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete;
qbyte *data, *mtdata;
char name[256];
- loadmodel->brushq1.textures = NULL;
+ loadmodel->brush.data_textures = NULL;
// add two slots for notexture walls and notexture liquids
if (l->filelen)
{
m = (dmiptexlump_t *)(mod_base + l->fileofs);
m->nummiptex = LittleLong (m->nummiptex);
- loadmodel->brushq1.numtextures = m->nummiptex + 2;
+ loadmodel->brush.num_textures = m->nummiptex + 2;
}
else
{
m = NULL;
- loadmodel->brushq1.numtextures = 2;
+ loadmodel->brush.num_textures = 2;
}
- loadmodel->brushq1.textures = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numtextures * sizeof(texture_t));
+ loadmodel->brush.data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_textures * sizeof(texture_t));
// fill out all slots with notexture
- for (i = 0, tx = loadmodel->brushq1.textures;i < loadmodel->brushq1.numtextures;i++, tx++)
+ for (i = 0, tx = loadmodel->brush.data_textures;i < loadmodel->brush.num_textures;i++, tx++)
{
- tx->number = i;
strcpy(tx->name, "NO TEXTURE FOUND");
tx->width = 16;
tx->height = 16;
- tx->skin.base = r_notexture;
- tx->shader = &Cshader_wall_lightmap;
- tx->flags = SURF_SOLIDCLIP;
- if (i == loadmodel->brushq1.numtextures - 1)
+ tx->skin.base = r_texture_notexture;
+ if (i == loadmodel->brush.num_textures - 1)
{
- tx->flags |= SURF_DRAWTURB | SURF_LIGHTBOTHSIDES;
- tx->shader = &Cshader_water;
+ tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES;
+ tx->supercontents = SUPERCONTENTS_WATER;
}
+ else
+ {
+ tx->basematerialflags |= MATERIALFLAG_WALL;
+ tx->supercontents = SUPERCONTENTS_SOLID;
+ }
+ tx->basematerialflags = 0;
tx->currentframe = tx;
}
}
if ((mtwidth & 15) || (mtheight & 15))
- Con_Printf("warning: texture \"%s\" in \"%s\" is not 16 aligned", dmiptex->name, loadmodel->name);
+ Con_Printf("warning: texture \"%s\" in \"%s\" is not 16 aligned\n", dmiptex->name, loadmodel->name);
// LordHavoc: force all names to lowercase
for (j = 0;name[j];j++)
if (name[j] >= 'A' && name[j] <= 'Z')
name[j] += 'a' - 'A';
- tx = loadmodel->brushq1.textures + i;
+ tx = loadmodel->brush.data_textures + i;
strcpy(tx->name, name);
tx->width = mtwidth;
tx->height = mtheight;
data = loadimagepixels(tx->name, false, 0, 0);
if (data)
{
- if (image_width == 256 && image_height == 128)
- {
- R_InitSky(data, 4);
- Mem_Free(data);
- }
- else
- {
- Mem_Free(data);
- Con_Printf("Invalid replacement texture for sky \"%s\" in %\"%s\", must be 256x128 pixels\n", tx->name, loadmodel->name);
- if (mtdata != NULL)
- R_InitSky(mtdata, 1);
- }
+ R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
+ Mem_Free(data);
}
else if (mtdata != NULL)
- R_InitSky(mtdata, 1);
+ R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
}
}
else
{
- if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, false, true, true))
+ if (!Mod_LoadSkinFrame(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', true))
{
// did not find external texture, load it from the bsp or wad3
if (loadmodel->brush.ishlbsp)
{
tx->width = image_width;
tx->height = image_height;
- tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ tx->skin.base = tx->skin.merged = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
if (Image_CheckAlpha(pixels, image_width * image_height, true))
{
fogpixels = Mem_Alloc(tempmempool, image_width * image_height * 4);
fogpixels[j + 2] = 255;
fogpixels[j + 3] = pixels[j + 3];
}
- tx->skin.fog = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ tx->skin.fog = R_LoadTexture2D(loadmodel->texturepool, tx->name, image_width, image_height, pixels, TEXTYPE_RGBA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, NULL);
Mem_Free(fogpixels);
}
}
Mem_Free(freepixels);
}
else if (mtdata) // texture included
- Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE, false, true, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
+ Mod_LoadSkinFrame_Internal(&tx->skin, tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, tx->name[0] != '*', tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
}
}
if (tx->skin.base == NULL)
// no texture found
tx->width = 16;
tx->height = 16;
- tx->skin.base = r_notexture;
+ tx->skin.base = r_texture_notexture;
}
+ tx->basematerialflags = 0;
if (tx->name[0] == '*')
{
// turb does not block movement
- tx->flags &= ~SURF_SOLIDCLIP;
- tx->flags |= SURF_DRAWTURB | SURF_LIGHTBOTHSIDES;
+ tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES;
// LordHavoc: some turbulent textures should be fullbright and solid
if (!strncmp(tx->name,"*lava",5)
|| !strncmp(tx->name,"*teleport",9)
|| !strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
- tx->flags |= SURF_DRAWFULLBRIGHT | SURF_DRAWNOALPHA;
+ tx->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
+ else
+ tx->basematerialflags |= MATERIALFLAG_WATERALPHA;
+ if (!strncmp(tx->name, "*lava", 5))
+ tx->supercontents = SUPERCONTENTS_LAVA;
+ else if (!strncmp(tx->name, "*slime", 6))
+ tx->supercontents = SUPERCONTENTS_SLIME;
else
- tx->flags |= SURF_WATERALPHA;
- tx->shader = &Cshader_water;
+ tx->supercontents = SUPERCONTENTS_WATER;
}
else if (tx->name[0] == 's' && tx->name[1] == 'k' && tx->name[2] == 'y')
{
- tx->flags |= SURF_DRAWSKY;
- tx->shader = &Cshader_sky;
+ tx->supercontents = SUPERCONTENTS_SKY;
+ tx->basematerialflags |= MATERIALFLAG_SKY;
}
else
{
- tx->flags |= SURF_LIGHTMAP;
- if (!tx->skin.fog)
- tx->flags |= SURF_SHADOWCAST | SURF_SHADOWLIGHT;
- tx->shader = &Cshader_wall_lightmap;
+ tx->supercontents = SUPERCONTENTS_SOLID;
+ tx->basematerialflags |= MATERIALFLAG_WALL;
}
+ if (tx->skin.fog)
+ tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT;
// start out with no animation
tx->currentframe = tx;
// sequence the animations
for (i = 0;i < m->nummiptex;i++)
{
- tx = loadmodel->brushq1.textures + i;
+ tx = loadmodel->brush.data_textures + i;
if (!tx || tx->name[0] != '+' || tx->name[1] == 0 || tx->name[2] == 0)
continue;
if (tx->anim_total[0] || tx->anim_total[1])
for (j = i;j < m->nummiptex;j++)
{
- tx2 = loadmodel->brushq1.textures + j;
+ tx2 = loadmodel->brush.data_textures + j;
if (!tx2 || tx2->name[0] != '+' || strcmp(tx2->name+2, tx->name+2))
continue;
if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
{
loadmodel->brushq1.lightdata = Mem_Alloc(loadmodel->mempool, l->filelen);
- memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
+ for (i=0; i<l->filelen; i++)
+ loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
}
else // LordHavoc: bsp version 29 (normal white lighting)
{
strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
strlcat (litfilename, ".lit", sizeof (litfilename));
- data = (qbyte*) FS_LoadFile(litfilename, false);
+ data = (qbyte*) FS_LoadFile(litfilename, tempmempool, false);
if (data)
{
if (fs_filesize > 8 && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
else
{
if (fs_filesize == 8)
- Con_Printf("Empty .lit file, ignoring\n");
+ Con_Print("Empty .lit file, ignoring\n");
else
- Con_Printf("Corrupt .lit file (old version?), ignoring\n");
+ Con_Print("Corrupt .lit file (old version?), ignoring\n");
Mem_Free(data);
}
}
static void Mod_Q1BSP_LoadLightList(void)
{
int a, n, numlights;
- char lightsfilename[1024], *s, *t, *lightsstring;
+ char tempchar, *s, *t, *lightsstring, lightsfilename[1024];
mlight_t *e;
strlcpy (lightsfilename, loadmodel->name, sizeof (lightsfilename));
FS_StripExtension (lightsfilename, lightsfilename, sizeof(lightsfilename));
strlcat (lightsfilename, ".lights", sizeof (lightsfilename));
- s = lightsstring = (char *) FS_LoadFile(lightsfilename, false);
+ s = lightsstring = (char *) FS_LoadFile(lightsfilename, tempmempool, false);
if (s)
{
numlights = 0;
while (*s)
{
- while (*s && *s != '\n')
+ while (*s && *s != '\n' && *s != '\r')
s++;
if (!*s)
{
Mem_Free(lightsstring);
- Host_Error("lights file must end with a newline\n");
+ Con_Printf("lights file must end with a newline\n");
+ return;
}
s++;
numlights++;
while (*s && n < numlights)
{
t = s;
- while (*s && *s != '\n')
+ while (*s && *s != '\n' && *s != '\r')
s++;
if (!*s)
{
- Mem_Free(lightsstring);
- Host_Error("misparsed lights file!\n");
+ Con_Printf("misparsed lights file!\n");
+ break;
}
e = loadmodel->brushq1.lights + n;
+ tempchar = *s;
*s = 0;
a = sscanf(t, "%f %f %f %f %f %f %f %f %f %f %f %f %f %d", &e->origin[0], &e->origin[1], &e->origin[2], &e->falloff, &e->light[0], &e->light[1], &e->light[2], &e->subtract, &e->spotdir[0], &e->spotdir[1], &e->spotdir[2], &e->spotcone, &e->distbias, &e->style);
- *s = '\n';
+ *s = tempchar;
if (a != 14)
{
- Mem_Free(lightsstring);
- Host_Error("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
+ Con_Printf("invalid lights file, found %d parameters on line %i, should be 14 parameters (origin[0] origin[1] origin[2] falloff light[0] light[1] light[2] subtract spotdir[0] spotdir[1] spotdir[2] spotcone distancebias style)\n", a, n + 1);
+ break;
}
- s++;
+ if (*s == '\r')
+ s++;
+ if (*s == '\n')
+ s++;
n++;
}
if (*s)
- {
- Mem_Free(lightsstring);
- Host_Error("misparsed lights file!\n");
- }
+ Con_Printf("misparsed lights file!\n");
loadmodel->brushq1.numlights = numlights;
Mem_Free(lightsstring);
}
out->flags = LittleLong(in->flags);
out->texture = NULL;
- if (loadmodel->brushq1.textures)
+ if (loadmodel->brush.data_textures)
{
- if ((unsigned int) miptex >= (unsigned int) loadmodel->brushq1.numtextures)
- Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->brushq1.numtextures);
+ if ((unsigned int) miptex >= (unsigned int) loadmodel->brush.num_textures)
+ Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->brush.num_textures);
else
- out->texture = loadmodel->brushq1.textures + miptex;
+ out->texture = loadmodel->brush.data_textures + miptex;
}
if (out->flags & TEX_SPECIAL)
{
// if texture chosen is NULL or the shader needs a lightmap,
// force to notexture water shader
- if (out->texture == NULL || out->texture->shader->flags & SHADERFLAGS_NEEDLIGHTMAP)
- out->texture = loadmodel->brushq1.textures + (loadmodel->brushq1.numtextures - 1);
+ if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
+ out->texture = loadmodel->brush.data_textures + (loadmodel->brush.num_textures - 1);
}
else
{
// if texture chosen is NULL, force to notexture
if (out->texture == NULL)
- out->texture = loadmodel->brushq1.textures + (loadmodel->brushq1.numtextures - 2);
+ out->texture = loadmodel->brush.data_textures + (loadmodel->brush.num_textures - 2);
}
}
}
{
if (subdivpolytriangles >= MAX_SUBDIVPOLYTRIANGLES)
{
- Con_Printf("SubdividePolygon: ran out of triangles in buffer, please increase your r_subdivide_size\n");
+ Con_Print("SubdividePolygon: ran out of triangles in buffer, please increase your r_subdivide_size\n");
return;
}
//Breaks a polygon up along axial 64 unit
//boundaries so that turbulent and sky warps
//can be done reasonably.
-static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surf)
+static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface)
{
int i, j;
surfvertex_t *v;
subdivpolytriangles = 0;
subdivpolyverts = 0;
- SubdividePolygon(surf->poly_numverts, surf->poly_verts);
+ SubdividePolygon(surface->mesh.num_vertices, surface->mesh.data_vertex3f);
if (subdivpolytriangles < 1)
Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?\n");
- surf->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
+ surface->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
mesh->num_vertices = subdivpolyverts;
mesh->num_triangles = subdivpolytriangles;
mesh->vertex = (surfvertex_t *)(mesh + 1);
for (i = 0, v = mesh->vertex;i < subdivpolyverts;i++, v++)
{
VectorCopy(subdivpolyvert[i], v->v);
- v->st[0] = DotProduct(v->v, surf->texinfo->vecs[0]);
- v->st[1] = DotProduct(v->v, surf->texinfo->vecs[1]);
+ v->st[0] = DotProduct(v->v, surface->texinfo->vecs[0]);
+ v->st[1] = DotProduct(v->v, surface->texinfo->vecs[1]);
}
}
#endif
-static surfmesh_t *Mod_Q1BSP_AllocSurfMesh(int numverts, int numtriangles)
-{
- surfmesh_t *mesh;
- mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + numtriangles * sizeof(int[6]) + numverts * (3 + 2 + 2 + 2 + 3 + 3 + 3 + 1) * sizeof(float));
- mesh->num_vertices = numverts;
- mesh->num_triangles = numtriangles;
- mesh->data_vertex3f = (float *)(mesh + 1);
- mesh->data_texcoordtexture2f = mesh->data_vertex3f + mesh->num_vertices * 3;
- mesh->data_texcoordlightmap2f = mesh->data_texcoordtexture2f + mesh->num_vertices * 2;
- mesh->data_texcoorddetail2f = mesh->data_texcoordlightmap2f + mesh->num_vertices * 2;
- mesh->data_svector3f = (float *)(mesh->data_texcoorddetail2f + mesh->num_vertices * 2);
- mesh->data_tvector3f = mesh->data_svector3f + mesh->num_vertices * 3;
- mesh->data_normal3f = mesh->data_tvector3f + mesh->num_vertices * 3;
- mesh->data_lightmapoffsets = (int *)(mesh->data_normal3f + mesh->num_vertices * 3);
- mesh->data_element3i = mesh->data_lightmapoffsets + mesh->num_vertices;
- mesh->data_neighbor3i = mesh->data_element3i + mesh->num_triangles * 3;
- return mesh;
-}
-
-static void Mod_Q1BSP_GenerateSurfacePolygon(msurface_t *surf, int firstedge, int numedges)
-{
- int i, lindex, j;
- float *vec, *vert, mins[3], maxs[3], val, *v;
- mtexinfo_t *tex;
-
- // convert edges back to a normal polygon
- surf->poly_numverts = numedges;
- vert = surf->poly_verts = Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * numedges);
- for (i = 0;i < numedges;i++)
- {
- lindex = loadmodel->brushq1.surfedges[firstedge + i];
- if (lindex > 0)
- vec = loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position;
- else
- vec = loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position;
- VectorCopy(vec, vert);
- vert += 3;
- }
-
- // calculate polygon bounding box and center
- vert = surf->poly_verts;
- VectorCopy(vert, mins);
- VectorCopy(vert, maxs);
- vert += 3;
- for (i = 1;i < surf->poly_numverts;i++, vert += 3)
- {
- if (mins[0] > vert[0]) mins[0] = vert[0];if (maxs[0] < vert[0]) maxs[0] = vert[0];
- if (mins[1] > vert[1]) mins[1] = vert[1];if (maxs[1] < vert[1]) maxs[1] = vert[1];
- if (mins[2] > vert[2]) mins[2] = vert[2];if (maxs[2] < vert[2]) maxs[2] = vert[2];
- }
- VectorCopy(mins, surf->poly_mins);
- VectorCopy(maxs, surf->poly_maxs);
- surf->poly_center[0] = (mins[0] + maxs[0]) * 0.5f;
- surf->poly_center[1] = (mins[1] + maxs[1]) * 0.5f;
- surf->poly_center[2] = (mins[2] + maxs[2]) * 0.5f;
-
- // generate surface extents information
- tex = surf->texinfo;
- mins[0] = maxs[0] = DotProduct(surf->poly_verts, tex->vecs[0]) + tex->vecs[0][3];
- mins[1] = maxs[1] = DotProduct(surf->poly_verts, tex->vecs[1]) + tex->vecs[1][3];
- for (i = 1, v = surf->poly_verts + 3;i < surf->poly_numverts;i++, v += 3)
- {
- for (j = 0;j < 2;j++)
- {
- val = DotProduct(v, tex->vecs[j]) + tex->vecs[j][3];
- if (mins[j] > val)
- mins[j] = val;
- if (maxs[j] < val)
- maxs[j] = val;
- }
- }
- for (i = 0;i < 2;i++)
- {
- surf->texturemins[i] = (int) floor(mins[i] / 16) * 16;
- surf->extents[i] = (int) ceil(maxs[i] / 16) * 16 - surf->texturemins[i];
- }
-}
-
static void Mod_Q1BSP_LoadFaces(lump_t *l)
{
dface_t *in;
- msurface_t *surf;
- int i, count, surfnum, planenum, ssize, tsize, firstedge, numedges, totalverts, totaltris, totalmeshes;
- surfmesh_t *mesh;
- float s, t;
+ msurface_t *surface;
+ int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris;
+ float texmins[2], texmaxs[2], val;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- loadmodel->brushq1.surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
+ loadmodel->brush.data_surfaces = Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
+
+ loadmodel->brush.num_surfaces = count;
+
+ totalverts = 0;
+ totaltris = 0;
+ for (surfacenum = 0, in = (void *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
+ {
+ numedges = LittleShort(in->numedges);
+ totalverts += numedges;
+ totaltris += numedges - 2;
+ }
- loadmodel->brushq1.numsurfaces = count;
- loadmodel->brushq1.surfacevisframes = Mem_Alloc(loadmodel->mempool, count * sizeof(int));
- loadmodel->brushq1.surfacepvsframes = Mem_Alloc(loadmodel->mempool, count * sizeof(int));
- loadmodel->brushq1.pvssurflist = Mem_Alloc(loadmodel->mempool, count * sizeof(int));
+ // TODO: split up into multiple meshes as needed to avoid exceeding 65536
+ // vertex limit
+ loadmodel->nummeshes = 1;
+ loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *));
+ loadmodel->meshlist[0] = Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, 0, 0, true, true, false);
- for (surfnum = 0, surf = loadmodel->brushq1.surfaces, totalverts = 0, totaltris = 0, totalmeshes = 0;surfnum < count;surfnum++, totalverts += surf->poly_numverts, totaltris += surf->poly_numverts - 2, totalmeshes++, in++, surf++)
+ totalverts = 0;
+ totaltris = 0;
+ for (surfacenum = 0, in = (void *)(mod_base + l->fileofs), surface = loadmodel->brush.data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
{
- surf->number = surfnum;
// FIXME: validate edges, texinfo, etc?
firstedge = LittleLong(in->firstedge);
numedges = LittleShort(in->numedges);
i = LittleShort(in->texinfo);
if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)\n", i, loadmodel->brushq1.numtexinfo);
- surf->texinfo = loadmodel->brushq1.texinfo + i;
- surf->flags = surf->texinfo->texture->flags;
+ surface->texinfo = loadmodel->brushq1.texinfo + i;
+ surface->texture = surface->texinfo->texture;
planenum = LittleShort(in->planenum);
- if ((unsigned int) planenum >= (unsigned int) loadmodel->brushq1.numplanes)
- Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)\n", planenum, loadmodel->brushq1.numplanes);
-
- if (LittleShort(in->side))
- surf->flags |= SURF_PLANEBACK;
-
- surf->plane = loadmodel->brushq1.planes + planenum;
+ if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
+ Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)\n", planenum, loadmodel->brush.num_planes);
+
+ //surface->flags = surface->texture->flags;
+ //if (LittleShort(in->side))
+ // surface->flags |= SURF_PLANEBACK;
+ //surface->plane = loadmodel->brush.data_planes + planenum;
+
+ surface->mesh.num_vertices = numedges;
+ surface->mesh.num_triangles = numedges - 2;
+ surface->mesh.data_vertex3f = loadmodel->meshlist[0]->data_vertex3f + totalverts * 3;
+ surface->mesh.data_texcoordtexture2f = loadmodel->meshlist[0]->data_texcoordtexture2f + totalverts * 2;
+ surface->mesh.data_texcoordlightmap2f = loadmodel->meshlist[0]->data_texcoordlightmap2f + totalverts * 2;
+ surface->mesh.data_texcoorddetail2f = loadmodel->meshlist[0]->data_texcoorddetail2f + totalverts * 2;
+ surface->mesh.data_svector3f = loadmodel->meshlist[0]->data_svector3f + totalverts * 3;
+ surface->mesh.data_tvector3f = loadmodel->meshlist[0]->data_tvector3f + totalverts * 3;
+ surface->mesh.data_normal3f = loadmodel->meshlist[0]->data_normal3f + totalverts * 3;
+ surface->mesh.data_lightmapoffsets = loadmodel->meshlist[0]->data_lightmapoffsets + totalverts;
+ surface->mesh.data_element3i = loadmodel->meshlist[0]->data_element3i + totaltris * 3;
+ surface->mesh.data_neighbor3i = loadmodel->meshlist[0]->data_neighbor3i + totaltris * 3;
+ totalverts += numedges;
+ totaltris += numedges - 2;
+
+ // convert edges back to a normal polygon
+ for (i = 0;i < surface->mesh.num_vertices;i++)
+ {
+ int lindex = loadmodel->brushq1.surfedges[firstedge + i];
+ float s, t;
+ if (lindex > 0)
+ VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position, surface->mesh.data_vertex3f + i * 3);
+ else
+ VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, surface->mesh.data_vertex3f + i * 3);
+ s = DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[0]) + surface->texinfo->vecs[0][3];
+ t = DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[1]) + surface->texinfo->vecs[1][3];
+ surface->mesh.data_texcoordtexture2f[i * 2 + 0] = s / surface->texture->width;
+ surface->mesh.data_texcoordtexture2f[i * 2 + 1] = t / surface->texture->height;
+ surface->mesh.data_texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
+ surface->mesh.data_texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
+ surface->mesh.data_texcoordlightmap2f[i * 2 + 0] = 0;
+ surface->mesh.data_texcoordlightmap2f[i * 2 + 1] = 0;
+ surface->mesh.data_lightmapoffsets[i] = 0;
+ }
- // clear lightmap (filled in later)
- surf->lightmaptexture = NULL;
+ for (i = 0;i < surface->mesh.num_triangles;i++)
+ {
+ surface->mesh.data_element3i[i * 3 + 0] = 0;
+ surface->mesh.data_element3i[i * 3 + 1] = i + 1;
+ surface->mesh.data_element3i[i * 3 + 2] = i + 2;
+ }
- // force lightmap upload on first time seeing the surface
- surf->cached_dlight = true;
+ // compile additional data about the surface geometry
+ Mod_BuildTriangleNeighbors(surface->mesh.data_neighbor3i, surface->mesh.data_element3i, surface->mesh.num_triangles);
+ Mod_BuildTextureVectorsAndNormals(surface->mesh.num_vertices, surface->mesh.num_triangles, surface->mesh.data_vertex3f, surface->mesh.data_texcoordtexture2f, surface->mesh.data_element3i, surface->mesh.data_svector3f, surface->mesh.data_tvector3f, surface->mesh.data_normal3f);
+ BoxFromPoints(surface->mins, surface->maxs, surface->mesh.num_vertices, surface->mesh.data_vertex3f);
- Mod_Q1BSP_GenerateSurfacePolygon(surf, firstedge, numedges);
+ // generate surface extents information
+ texmins[0] = texmaxs[0] = DotProduct(surface->mesh.data_vertex3f, surface->texinfo->vecs[0]) + surface->texinfo->vecs[0][3];
+ texmins[1] = texmaxs[1] = DotProduct(surface->mesh.data_vertex3f, surface->texinfo->vecs[1]) + surface->texinfo->vecs[1][3];
+ for (i = 1;i < surface->mesh.num_vertices;i++)
+ {
+ for (j = 0;j < 2;j++)
+ {
+ val = DotProduct(surface->mesh.data_vertex3f + i * 3, surface->texinfo->vecs[j]) + surface->texinfo->vecs[j][3];
+ texmins[j] = min(texmins[j], val);
+ texmaxs[j] = max(texmaxs[j], val);
+ }
+ }
+ for (i = 0;i < 2;i++)
+ {
+ surface->texturemins[i] = (int) floor(texmins[i] / 16.0) * 16;
+ surface->extents[i] = (int) ceil(texmaxs[i] / 16.0) * 16 - surface->texturemins[i];
+ }
- ssize = (surf->extents[0] >> 4) + 1;
- tsize = (surf->extents[1] >> 4) + 1;
+ smax = surface->extents[0] >> 4;
+ tmax = surface->extents[1] >> 4;
+ ssize = (surface->extents[0] >> 4) + 1;
+ tsize = (surface->extents[1] >> 4) + 1;
// lighting info
for (i = 0;i < MAXLIGHTMAPS;i++)
- surf->styles[i] = in->styles[i];
+ surface->styles[i] = in->styles[i];
+ // force lightmap upload on first time seeing the surface
+ surface->cached_dlight = true;
+ surface->lightmaptexturestride = 0;
+ surface->lightmaptexture = NULL;
i = LittleLong(in->lightofs);
if (i == -1)
- surf->samples = NULL;
+ {
+ surface->samples = NULL;
+ // give non-lightmapped water a 1x white lightmap
+ if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
+ {
+ surface->samples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ surface->styles[0] = 0;
+ memset(surface->samples, 128, ssize * tsize * 3);
+ }
+ }
else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30)
- surf->samples = loadmodel->brushq1.lightdata + i;
+ surface->samples = loadmodel->brushq1.lightdata + i;
else // LordHavoc: white lighting (bsp version 29)
- surf->samples = loadmodel->brushq1.lightdata + (i * 3);
+ surface->samples = loadmodel->brushq1.lightdata + (i * 3);
- if (surf->texinfo->texture->shader == &Cshader_wall_lightmap)
+ if (!(surface->texinfo->flags & TEX_SPECIAL) || surface->samples)
{
- if ((surf->extents[0] >> 4) + 1 > (256) || (surf->extents[1] >> 4) + 1 > (256))
+ int i, iu, iv;
+ float u, v, ubase, vbase, uscale, vscale;
+
+ if (ssize > 256 || tsize > 256)
Host_Error("Bad surface extents");
// stainmap for permanent marks on walls
- surf->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ surface->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
// clear to white
- memset(surf->stainsamples, 255, ssize * tsize * 3);
- }
- }
-
- loadmodel->brushq1.entiremesh = Mod_Q1BSP_AllocSurfMesh(totalverts, totaltris);
-
- for (surfnum = 0, surf = loadmodel->brushq1.surfaces, totalverts = 0, totaltris = 0, totalmeshes = 0;surfnum < count;surfnum++, totalverts += surf->poly_numverts, totaltris += surf->poly_numverts - 2, totalmeshes++, surf++)
- {
- mesh = &surf->mesh;
- mesh->num_vertices = surf->poly_numverts;
- mesh->num_triangles = surf->poly_numverts - 2;
- mesh->data_vertex3f = loadmodel->brushq1.entiremesh->data_vertex3f + totalverts * 3;
- mesh->data_texcoordtexture2f = loadmodel->brushq1.entiremesh->data_texcoordtexture2f + totalverts * 2;
- mesh->data_texcoordlightmap2f = loadmodel->brushq1.entiremesh->data_texcoordlightmap2f + totalverts * 2;
- mesh->data_texcoorddetail2f = loadmodel->brushq1.entiremesh->data_texcoorddetail2f + totalverts * 2;
- mesh->data_svector3f = loadmodel->brushq1.entiremesh->data_svector3f + totalverts * 3;
- mesh->data_tvector3f = loadmodel->brushq1.entiremesh->data_tvector3f + totalverts * 3;
- mesh->data_normal3f = loadmodel->brushq1.entiremesh->data_normal3f + totalverts * 3;
- mesh->data_lightmapoffsets = loadmodel->brushq1.entiremesh->data_lightmapoffsets + totalverts;
- mesh->data_element3i = loadmodel->brushq1.entiremesh->data_element3i + totaltris * 3;
- mesh->data_neighbor3i = loadmodel->brushq1.entiremesh->data_neighbor3i + totaltris * 3;
+ memset(surface->stainsamples, 255, ssize * tsize * 3);
- surf->lightmaptexturestride = 0;
- surf->lightmaptexture = NULL;
-
- for (i = 0;i < mesh->num_vertices;i++)
- {
- mesh->data_vertex3f[i * 3 + 0] = surf->poly_verts[i * 3 + 0];
- mesh->data_vertex3f[i * 3 + 1] = surf->poly_verts[i * 3 + 1];
- mesh->data_vertex3f[i * 3 + 2] = surf->poly_verts[i * 3 + 2];
- s = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3];
- t = DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3];
- mesh->data_texcoordtexture2f[i * 2 + 0] = s / surf->texinfo->texture->width;
- mesh->data_texcoordtexture2f[i * 2 + 1] = t / surf->texinfo->texture->height;
- mesh->data_texcoorddetail2f[i * 2 + 0] = s * (1.0f / 16.0f);
- mesh->data_texcoorddetail2f[i * 2 + 1] = t * (1.0f / 16.0f);
- mesh->data_texcoordlightmap2f[i * 2 + 0] = 0;
- mesh->data_texcoordlightmap2f[i * 2 + 1] = 0;
- mesh->data_lightmapoffsets[i] = 0;
- }
-
- for (i = 0;i < mesh->num_triangles;i++)
- {
- mesh->data_element3i[i * 3 + 0] = 0;
- mesh->data_element3i[i * 3 + 1] = i + 1;
- mesh->data_element3i[i * 3 + 2] = i + 2;
- }
-
- Mod_BuildTriangleNeighbors(mesh->data_neighbor3i, mesh->data_element3i, mesh->num_triangles);
- Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, mesh->data_vertex3f, mesh->data_texcoordtexture2f, mesh->data_element3i, mesh->data_svector3f, mesh->data_tvector3f, mesh->data_normal3f);
-
- if (surf->texinfo->texture->shader == &Cshader_wall_lightmap)
- {
- int i, iu, iv, smax, tmax;
- float u, v, ubase, vbase, uscale, vscale;
-
- smax = surf->extents[0] >> 4;
- tmax = surf->extents[1] >> 4;
-
- surf->flags |= SURF_LIGHTMAP;
if (r_miplightmaps.integer)
{
- surf->lightmaptexturestride = smax+1;
- surf->lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP | TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ surface->lightmaptexturestride = ssize;
+ surface->lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, NULL, surface->lightmaptexturestride, tsize, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP | TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
}
else
{
- surf->lightmaptexturestride = R_CompatibleFragmentWidth(smax+1, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, 0);
- surf->lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ surface->lightmaptexturestride = R_CompatibleFragmentWidth(ssize, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, 0);
+ surface->lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, NULL, surface->lightmaptexturestride, tsize, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
}
- R_FragmentLocation(surf->lightmaptexture, NULL, NULL, &ubase, &vbase, &uscale, &vscale);
- uscale = (uscale - ubase) / (smax + 1);
- vscale = (vscale - vbase) / (tmax + 1);
+ R_FragmentLocation(surface->lightmaptexture, NULL, NULL, &ubase, &vbase, &uscale, &vscale);
+ uscale = (uscale - ubase) / ssize;
+ vscale = (vscale - vbase) / tsize;
- for (i = 0;i < mesh->num_vertices;i++)
+ for (i = 0;i < surface->mesh.num_vertices;i++)
{
- u = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[0]) + surf->texinfo->vecs[0][3]) + 8 - surf->texturemins[0]) * (1.0 / 16.0);
- v = ((DotProduct((mesh->data_vertex3f + i * 3), surf->texinfo->vecs[1]) + surf->texinfo->vecs[1][3]) + 8 - surf->texturemins[1]) * (1.0 / 16.0);
- mesh->data_texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
- mesh->data_texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
+ u = ((DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[0]) + surface->texinfo->vecs[0][3]) + 8 - surface->texturemins[0]) * (1.0 / 16.0);
+ v = ((DotProduct((surface->mesh.data_vertex3f + i * 3), surface->texinfo->vecs[1]) + surface->texinfo->vecs[1][3]) + 8 - surface->texturemins[1]) * (1.0 / 16.0);
+ surface->mesh.data_texcoordlightmap2f[i * 2 + 0] = u * uscale + ubase;
+ surface->mesh.data_texcoordlightmap2f[i * 2 + 1] = v * vscale + vbase;
// LordHavoc: calc lightmap data offset for vertex lighting to use
iu = (int) u;
iv = (int) v;
- mesh->data_lightmapoffsets[i] = (bound(0, iv, tmax) * (smax+1) + bound(0, iu, smax)) * 3;
+ surface->mesh.data_lightmapoffsets[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
}
}
}
}
-static void Mod_Q1BSP_SetParent(mnode_t *node, mnode_t *parent)
+static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
{
+ //if (node->parent)
+ // Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion\n");
node->parent = parent;
- if (node->contents < 0)
- return;
- Mod_Q1BSP_SetParent(node->children[0], node);
- Mod_Q1BSP_SetParent(node->children[1], node);
+ if (node->plane)
+ {
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
+ }
}
static void Mod_Q1BSP_LoadNodes(lump_t *l)
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
- loadmodel->brushq1.nodes = out;
- loadmodel->brushq1.numnodes = count;
+ loadmodel->brush.data_nodes = out;
+ loadmodel->brush.num_nodes = count;
for ( i=0 ; i<count ; i++, in++, out++)
{
}
p = LittleLong(in->planenum);
- out->plane = loadmodel->brushq1.planes + p;
+ out->plane = loadmodel->brush.data_planes + p;
out->firstsurface = LittleShort(in->firstface);
out->numsurfaces = LittleShort(in->numfaces);
{
p = LittleShort(in->children[j]);
if (p >= 0)
- out->children[j] = loadmodel->brushq1.nodes + p;
+ out->children[j] = loadmodel->brush.data_nodes + p;
else
- out->children[j] = (mnode_t *)(loadmodel->brushq1.leafs + (-1 - p));
+ out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p));
}
}
- Mod_Q1BSP_SetParent(loadmodel->brushq1.nodes, NULL); // sets nodes and leafs
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL); // sets nodes and leafs
}
static void Mod_Q1BSP_LoadLeafs(lump_t *l)
{
dleaf_t *in;
mleaf_t *out;
- int i, j, count, p, pvschainbytes;
- qbyte *pvs;
+ int i, j, count, p;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
- loadmodel->brushq1.leafs = out;
- loadmodel->brushq1.numleafs = count;
- pvschainbytes = ((loadmodel->brushq1.numleafs - 1)+7)>>3;
- loadmodel->brushq1.data_decompressedpvs = pvs = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numleafs * pvschainbytes);
+ loadmodel->brush.data_leafs = out;
+ loadmodel->brush.num_leafs = count;
+ // get visleafs from the submodel data
+ loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
+ loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
+ loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
+ memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
for ( i=0 ; i<count ; i++, in++, out++)
{
out->contents = LittleLong(in->contents);
- out->firstmarksurface = loadmodel->brushq1.marksurfaces + LittleShort(in->firstmarksurface);
- out->nummarksurfaces = LittleShort(in->nummarksurfaces);
- if (out->firstmarksurface < 0 || LittleShort(in->firstmarksurface) + out->nummarksurfaces > loadmodel->brushq1.nummarksurfaces)
+ out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface);
+ out->numleafsurfaces = LittleShort(in->nummarksurfaces);
+ if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
{
- Con_Printf("Mod_Q1BSP_LoadLeafs: invalid marksurface range %i:%i outside range %i:%i\n", out->firstmarksurface, out->firstmarksurface + out->nummarksurfaces, 0, loadmodel->brushq1.nummarksurfaces);
- out->firstmarksurface = NULL;
- out->nummarksurfaces = 0;
+ Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", out->firstleafsurface, out->firstleafsurface + out->numleafsurfaces, 0, loadmodel->brush.num_leafsurfaces);
+ out->firstleafsurface = NULL;
+ out->numleafsurfaces = 0;
}
- out->pvsdata = pvs;
- memset(out->pvsdata, 0xFF, pvschainbytes);
- pvs += pvschainbytes;
+ out->clusterindex = i - 1;
+ if (out->clusterindex >= loadmodel->brush.num_pvsclusters)
+ out->clusterindex = -1;
p = LittleLong(in->visofs);
- if (p >= 0)
+ // ignore visofs errors on leaf 0 (solid)
+ if (p >= 0 && out->clusterindex >= 0)
{
if (p >= loadmodel->brushq1.num_compressedpvs)
- Con_Printf("Mod_Q1BSP_LoadLeafs: invalid visofs\n");
+ Con_Print("Mod_Q1BSP_LoadLeafs: invalid visofs\n");
else
- Mod_Q1BSP_DecompressVis(loadmodel->brushq1.data_compressedpvs + p, loadmodel->brushq1.data_compressedpvs + loadmodel->brushq1.num_compressedpvs, out->pvsdata, out->pvsdata + pvschainbytes);
+ Mod_Q1BSP_DecompressVis(loadmodel->brushq1.data_compressedpvs + p, loadmodel->brushq1.data_compressedpvs + loadmodel->brushq1.num_compressedpvs, loadmodel->brush.data_pvsclusters + out->clusterindex * loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.data_pvsclusters + (out->clusterindex + 1) * loadmodel->brush.num_pvsclusterbytes);
}
for (j = 0;j < 4;j++)
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->planes = loadmodel->brush.data_planes;
hull->clip_mins[0] = -16;
hull->clip_mins[1] = -16;
hull->clip_mins[2] = -36;
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->planes = loadmodel->brush.data_planes;
hull->clip_mins[0] = -32;
hull->clip_mins[1] = -32;
hull->clip_mins[2] = -32;
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->planes = loadmodel->brush.data_planes;
hull->clip_mins[0] = -16;
hull->clip_mins[1] = -16;
hull->clip_mins[2] = -18;
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->planes = loadmodel->brush.data_planes;
hull->clip_mins[0] = -16;
hull->clip_mins[1] = -16;
hull->clip_mins[2] = -24;
hull->clipnodes = out;
hull->firstclipnode = 0;
hull->lastclipnode = count-1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->planes = loadmodel->brush.data_planes;
hull->clip_mins[0] = -32;
hull->clip_mins[1] = -32;
hull->clip_mins[2] = -24;
hull = &loadmodel->brushq1.hulls[0];
- in = loadmodel->brushq1.nodes;
- out = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numnodes * sizeof(dclipnode_t));
+ in = loadmodel->brush.data_nodes;
+ out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
hull->clipnodes = out;
hull->firstclipnode = 0;
- hull->lastclipnode = loadmodel->brushq1.numnodes - 1;
- hull->planes = loadmodel->brushq1.planes;
+ hull->lastclipnode = loadmodel->brush.num_nodes - 1;
+ hull->planes = loadmodel->brush.data_planes;
- for (i = 0;i < loadmodel->brushq1.numnodes;i++, out++, in++)
+ for (i = 0;i < loadmodel->brush.num_nodes;i++, out++, in++)
{
- out->planenum = in->plane - loadmodel->brushq1.planes;
- out->children[0] = in->children[0]->contents < 0 ? in->children[0]->contents : in->children[0] - loadmodel->brushq1.nodes;
- out->children[1] = in->children[1]->contents < 0 ? in->children[1]->contents : in->children[1] - loadmodel->brushq1.nodes;
+ out->planenum = in->plane - loadmodel->brush.data_planes;
+ out->children[0] = in->children[0]->plane ? in->children[0] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[0])->contents;
+ out->children[1] = in->children[1]->plane ? in->children[1] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[1])->contents;
}
}
-static void Mod_Q1BSP_LoadMarksurfaces(lump_t *l)
+static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
{
int i, j;
short *in;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
- Host_Error("Mod_Q1BSP_LoadMarksurfaces: funny lump size in %s",loadmodel->name);
- loadmodel->brushq1.nummarksurfaces = l->filelen / sizeof(*in);
- loadmodel->brushq1.marksurfaces = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.nummarksurfaces * sizeof(int));
+ Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
+ loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
+ loadmodel->brush.data_leafsurfaces = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
- for (i = 0;i < loadmodel->brushq1.nummarksurfaces;i++)
+ for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
{
j = (unsigned) LittleShort(in[i]);
- if (j >= loadmodel->brushq1.numsurfaces)
- Host_Error("Mod_Q1BSP_LoadMarksurfaces: bad surface number");
- loadmodel->brushq1.marksurfaces[i] = j;
+ if (j >= loadmodel->brush.num_surfaces)
+ Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
+ loadmodel->brush.data_leafsurfaces[i] = j;
}
}
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
- loadmodel->brushq1.numplanes = l->filelen / sizeof(*in);
- loadmodel->brushq1.planes = out = Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numplanes * sizeof(*out));
+ loadmodel->brush.num_planes = l->filelen / sizeof(*in);
+ loadmodel->brush.data_planes = out = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
- for (i = 0;i < loadmodel->brushq1.numplanes;i++, in++, out++)
+ for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
{
out->normal[0] = LittleFloat(in->normal[0]);
out->normal[1] = LittleFloat(in->normal[1]);
}
}
-typedef struct portal_s
-{
- mplane_t plane;
- mnode_t *nodes[2]; // [0] = front side of plane
- struct portal_s *next[2];
- winding_t *winding;
- struct portal_s *chain; // all portals are linked into a list
-}
-portal_t;
-
-static portal_t *portalchain;
-
-/*
-===========
-AllocPortal
-===========
-*/
-static portal_t *AllocPortal(void)
+static void Mod_Q1BSP_LoadMapBrushes(void)
+{
+#if 0
+// unfinished
+ int submodel, numbrushes;
+ qboolean firstbrush;
+ char *text, *maptext;
+ char mapfilename[MAX_QPATH];
+ FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
+ strlcat (mapfilename, ".map", sizeof (mapfilename));
+ maptext = (qbyte*) FS_LoadFile(mapfilename, tempmempool, false);
+ if (!maptext)
+ return;
+ text = maptext;
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ submodel = 0;
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ break;
+ if (com_token[0] != '{')
+ return; // error
+ // entity
+ firstbrush = true;
+ numbrushes = 0;
+ maxbrushes = 256;
+ brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ if (com_token[0] == '}')
+ break; // end of entity
+ if (com_token[0] == '{')
+ {
+ // brush
+ if (firstbrush)
+ {
+ if (submodel)
+ {
+ if (submodel > loadmodel->brush.numsubmodels)
+ {
+ Con_Printf("Mod_Q1BSP_LoadMapBrushes: .map has more submodels than .bsp!\n");
+ model = NULL;
+ }
+ else
+ model = loadmodel->brush.submodels[submodel];
+ }
+ else
+ model = loadmodel;
+ }
+ for (;;)
+ {
+ if (!COM_ParseToken(&data, false))
+ return; // error
+ if (com_token[0] == '}')
+ break; // end of brush
+ // each brush face should be this format:
+ // ( x y z ) ( x y z ) ( x y z ) texture scroll_s scroll_t rotateangle scale_s scale_t
+ // FIXME: support hl .map format
+ for (pointnum = 0;pointnum < 3;pointnum++)
+ {
+ COM_ParseToken(&data, false);
+ for (componentnum = 0;componentnum < 3;componentnum++)
+ {
+ COM_ParseToken(&data, false);
+ point[pointnum][componentnum] = atof(com_token);
+ }
+ COM_ParseToken(&data, false);
+ }
+ COM_ParseToken(&data, false);
+ strlcpy(facetexture, com_token, sizeof(facetexture));
+ COM_ParseToken(&data, false);
+ //scroll_s = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scroll_t = atof(com_token);
+ COM_ParseToken(&data, false);
+ //rotate = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scale_s = atof(com_token);
+ COM_ParseToken(&data, false);
+ //scale_t = atof(com_token);
+ TriangleNormal(point[0], point[1], point[2], planenormal);
+ VectorNormalizeDouble(planenormal);
+ planedist = DotProduct(point[0], planenormal);
+ //ChooseTexturePlane(planenormal, texturevector[0], texturevector[1]);
+ }
+ continue;
+ }
+ }
+ }
+#endif
+}
+
+
+#define MAX_PORTALPOINTS 64
+
+typedef struct portal_s
+{
+ mplane_t plane;
+ mnode_t *nodes[2]; // [0] = front side of plane
+ struct portal_s *next[2];
+ int numpoints;
+ double points[3*MAX_PORTALPOINTS];
+ struct portal_s *chain; // all portals are linked into a list
+}
+portal_t;
+
+static portal_t *portalchain;
+
+/*
+===========
+AllocPortal
+===========
+*/
+static portal_t *AllocPortal(void)
{
portal_t *p;
p = Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
{
+ // process only nodes (leafs already had their box calculated)
+ if (!node->plane)
+ return;
+
// calculate children first
- if (node->children[0]->contents >= 0)
- Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[0]);
- if (node->children[1]->contents >= 0)
- Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[1]);
+ Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[0]);
+ Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[1]);
// make combined bounding box from children
node->mins[0] = min(node->children[0]->mins[0], node->children[1]->mins[0]);
mportal_t *portal;
mvertex_t *point;
mleaf_t *leaf, *endleaf;
- winding_t *w;
// recalculate bounding boxes for all leafs(because qbsp is very sloppy)
- leaf = loadmodel->brushq1.leafs;
- endleaf = leaf + loadmodel->brushq1.numleafs;
+ leaf = loadmodel->brush.data_leafs;
+ endleaf = leaf + loadmodel->brush.num_leafs;
for (;leaf < endleaf;leaf++)
{
VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000);
p = portalchain;
while (p)
{
- if (p->winding)
+ if (p->numpoints >= 3)
{
for (i = 0;i < 2;i++)
{
leaf = (mleaf_t *)p->nodes[i];
- w = p->winding;
- for (j = 0;j < w->numpoints;j++)
+ for (j = 0;j < p->numpoints;j++)
{
- if (leaf->mins[0] > w->points[j][0]) leaf->mins[0] = w->points[j][0];
- if (leaf->mins[1] > w->points[j][1]) leaf->mins[1] = w->points[j][1];
- if (leaf->mins[2] > w->points[j][2]) leaf->mins[2] = w->points[j][2];
- if (leaf->maxs[0] < w->points[j][0]) leaf->maxs[0] = w->points[j][0];
- if (leaf->maxs[1] < w->points[j][1]) leaf->maxs[1] = w->points[j][1];
- if (leaf->maxs[2] < w->points[j][2]) leaf->maxs[2] = w->points[j][2];
+ if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
+ if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
+ if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
+ if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
+ if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
+ if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
}
}
}
p = p->chain;
}
- Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brushq1.nodes);
+ Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
// tally up portal and point counts
p = portalchain;
{
// note: this check must match the one below or it will usually corrupt memory
// the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
- if (p->winding && p->nodes[0] != p->nodes[1]
- && p->nodes[0]->contents != CONTENTS_SOLID && p->nodes[1]->contents != CONTENTS_SOLID
- && p->nodes[0]->contents != CONTENTS_SKY && p->nodes[1]->contents != CONTENTS_SKY)
+ if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
{
numportals += 2;
- numpoints += p->winding->numpoints * 2;
+ numpoints += p->numpoints * 2;
}
p = p->chain;
}
- loadmodel->brushq1.portals = Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
- loadmodel->brushq1.numportals = numportals;
- loadmodel->brushq1.portalpoints = (void *)((qbyte *) loadmodel->brushq1.portals + numportals * sizeof(mportal_t));
- loadmodel->brushq1.numportalpoints = numpoints;
+ loadmodel->brush.data_portals = Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
+ loadmodel->brush.num_portals = numportals;
+ loadmodel->brush.data_portalpoints = (void *)((qbyte *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
+ loadmodel->brush.num_portalpoints = numpoints;
// clear all leaf portal chains
- for (i = 0;i < loadmodel->brushq1.numleafs;i++)
- loadmodel->brushq1.leafs[i].portals = NULL;
+ for (i = 0;i < loadmodel->brush.num_leafs;i++)
+ loadmodel->brush.data_leafs[i].portals = NULL;
// process all portals in the global portal chain, while freeing them
- portal = loadmodel->brushq1.portals;
- point = loadmodel->brushq1.portalpoints;
+ portal = loadmodel->brush.data_portals;
+ point = loadmodel->brush.data_portalpoints;
p = portalchain;
portalchain = NULL;
while (p)
{
pnext = p->chain;
- if (p->winding)
+ // note: this check must match the one above or it will usually corrupt memory
+ // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
+ if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
{
- // note: this check must match the one above or it will usually corrupt memory
- // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
- if (p->nodes[0] != p->nodes[1]
- && p->nodes[0]->contents != CONTENTS_SOLID && p->nodes[1]->contents != CONTENTS_SOLID
- && p->nodes[0]->contents != CONTENTS_SKY && p->nodes[1]->contents != CONTENTS_SKY)
+ // first make the back to front portal(forward portal)
+ portal->points = point;
+ portal->numpoints = p->numpoints;
+ portal->plane.dist = p->plane.dist;
+ VectorCopy(p->plane.normal, portal->plane.normal);
+ portal->here = (mleaf_t *)p->nodes[1];
+ portal->past = (mleaf_t *)p->nodes[0];
+ // copy points
+ for (j = 0;j < portal->numpoints;j++)
{
- // first make the back to front portal(forward portal)
- portal->points = point;
- portal->numpoints = p->winding->numpoints;
- portal->plane.dist = p->plane.dist;
- VectorCopy(p->plane.normal, portal->plane.normal);
- portal->here = (mleaf_t *)p->nodes[1];
- portal->past = (mleaf_t *)p->nodes[0];
- // copy points
- for (j = 0;j < portal->numpoints;j++)
- {
- VectorCopy(p->winding->points[j], point->position);
- point++;
- }
- PlaneClassify(&portal->plane);
-
- // link into leaf's portal chain
- portal->next = portal->here->portals;
- portal->here->portals = portal;
-
- // advance to next portal
- portal++;
-
- // then make the front to back portal(backward portal)
- portal->points = point;
- portal->numpoints = p->winding->numpoints;
- portal->plane.dist = -p->plane.dist;
- VectorNegate(p->plane.normal, portal->plane.normal);
- portal->here = (mleaf_t *)p->nodes[0];
- portal->past = (mleaf_t *)p->nodes[1];
- // copy points
- for (j = portal->numpoints - 1;j >= 0;j--)
- {
- VectorCopy(p->winding->points[j], point->position);
- point++;
- }
- PlaneClassify(&portal->plane);
+ VectorCopy(p->points + j*3, point->position);
+ point++;
+ }
+ BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+ PlaneClassify(&portal->plane);
+
+ // link into leaf's portal chain
+ portal->next = portal->here->portals;
+ portal->here->portals = portal;
+
+ // advance to next portal
+ portal++;
+
+ // then make the front to back portal(backward portal)
+ portal->points = point;
+ portal->numpoints = p->numpoints;
+ portal->plane.dist = -p->plane.dist;
+ VectorNegate(p->plane.normal, portal->plane.normal);
+ portal->here = (mleaf_t *)p->nodes[0];
+ portal->past = (mleaf_t *)p->nodes[1];
+ // copy points
+ for (j = portal->numpoints - 1;j >= 0;j--)
+ {
+ VectorCopy(p->points + j*3, point->position);
+ point++;
+ }
+ BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
+ PlaneClassify(&portal->plane);
- // link into leaf's portal chain
- portal->next = portal->here->portals;
- portal->here->portals = portal;
+ // link into leaf's portal chain
+ portal->next = portal->here->portals;
+ portal->here->portals = portal;
- // advance to next portal
- portal++;
- }
- Winding_Free(p->winding);
+ // advance to next portal
+ portal++;
}
FreePortal(p);
p = pnext;
static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
{
- int side;
+ int i, side;
mnode_t *front, *back, *other_node;
mplane_t clipplane, *plane;
portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp;
- winding_t *nodeportalwinding, *frontwinding, *backwinding;
+ int numfrontpoints, numbackpoints;
+ double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS];
// if a leaf, we're done
- if (node->contents)
+ if (!node->plane)
return;
plane = node->plane;
nodeportal = AllocPortal();
nodeportal->plane = *plane;
- nodeportalwinding = Winding_NewFromPlane(nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist);
+ PolygonD_QuadForPlane(nodeportal->points, nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist, 1024.0*1024.0*1024.0);
+ nodeportal->numpoints = 4;
side = 0; // shut up compiler warning
for (portal = (portal_t *)node->portals;portal;portal = portal->next[side])
{
else
Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
- nodeportalwinding = Winding_Clip(nodeportalwinding, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, true);
- if (!nodeportalwinding)
- {
- Con_Printf("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
+ for (i = 0;i < nodeportal->numpoints*3;i++)
+ frontpoints[i] = nodeportal->points[i];
+ PolygonD_Divide(nodeportal->numpoints, frontpoints, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, 1.0/32.0, MAX_PORTALPOINTS, nodeportal->points, &nodeportal->numpoints, 0, NULL, NULL);
+ if (nodeportal->numpoints <= 0 || nodeportal->numpoints >= MAX_PORTALPOINTS)
break;
- }
}
- if (nodeportalwinding)
+ if (nodeportal->numpoints < 3)
{
- // if the plane was not clipped on all sides, there was an error
- nodeportal->winding = nodeportalwinding;
- AddPortalToNodes(nodeportal, front, back);
+ Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
+ nodeportal->numpoints = 0;
}
-
- // split the portals of this node along this node's plane and assign them to the children of this node
- // (migrating the portals downward through the tree)
- for (portal = (portal_t *)node->portals;portal;portal = nextportal)
+ else if (nodeportal->numpoints >= MAX_PORTALPOINTS)
{
- if (portal->nodes[0] == portal->nodes[1])
- Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
- if (portal->nodes[0] == node)
- side = 0;
- else if (portal->nodes[1] == node)
- side = 1;
- else
- Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
- nextportal = portal->next[side];
-
- other_node = portal->nodes[!side];
- RemovePortalFromNodes(portal);
-
- // cut the portal into two portals, one on each side of the node plane
- Winding_Divide(portal->winding, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, &frontwinding, &backwinding);
+ Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal has too many points\n");
+ nodeportal->numpoints = 0;
+ }
+ else
+ {
+ AddPortalToNodes(nodeportal, front, back);
- if (!frontwinding)
+ // split the portals of this node along this node's plane and assign them to the children of this node
+ // (migrating the portals downward through the tree)
+ for (portal = (portal_t *)node->portals;portal;portal = nextportal)
{
- if (side == 0)
- AddPortalToNodes(portal, back, other_node);
+ if (portal->nodes[0] == portal->nodes[1])
+ Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
+ if (portal->nodes[0] == node)
+ side = 0;
+ else if (portal->nodes[1] == node)
+ side = 1;
else
- AddPortalToNodes(portal, other_node, back);
- continue;
- }
- if (!backwinding)
- {
+ Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
+ nextportal = portal->next[side];
+
+ other_node = portal->nodes[!side];
+ RemovePortalFromNodes(portal);
+
+ // cut the portal into two portals, one on each side of the node plane
+ PolygonD_Divide(portal->numpoints, portal->points, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, 1.0/32.0, MAX_PORTALPOINTS, frontpoints, &numfrontpoints, MAX_PORTALPOINTS, backpoints, &numbackpoints);
+
+ if (!numfrontpoints)
+ {
+ if (side == 0)
+ AddPortalToNodes(portal, back, other_node);
+ else
+ AddPortalToNodes(portal, other_node, back);
+ continue;
+ }
+ if (!numbackpoints)
+ {
+ if (side == 0)
+ AddPortalToNodes(portal, front, other_node);
+ else
+ AddPortalToNodes(portal, other_node, front);
+ continue;
+ }
+
+ // the portal is split
+ splitportal = AllocPortal();
+ temp = splitportal->chain;
+ *splitportal = *portal;
+ splitportal->chain = temp;
+ for (i = 0;i < numbackpoints*3;i++)
+ splitportal->points[i] = backpoints[i];
+ splitportal->numpoints = numbackpoints;
+ for (i = 0;i < numfrontpoints*3;i++)
+ portal->points[i] = frontpoints[i];
+ portal->numpoints = numfrontpoints;
+
if (side == 0)
+ {
AddPortalToNodes(portal, front, other_node);
+ AddPortalToNodes(splitportal, back, other_node);
+ }
else
+ {
AddPortalToNodes(portal, other_node, front);
- continue;
- }
-
- // the winding is split
- splitportal = AllocPortal();
- temp = splitportal->chain;
- *splitportal = *portal;
- splitportal->chain = temp;
- splitportal->winding = backwinding;
- Winding_Free(portal->winding);
- portal->winding = frontwinding;
-
- if (side == 0)
- {
- AddPortalToNodes(portal, front, other_node);
- AddPortalToNodes(splitportal, back, other_node);
- }
- else
- {
- AddPortalToNodes(portal, other_node, front);
- AddPortalToNodes(splitportal, other_node, back);
+ AddPortalToNodes(splitportal, other_node, back);
+ }
}
}
static void Mod_Q1BSP_MakePortals(void)
{
portalchain = NULL;
- Mod_Q1BSP_RecursiveNodePortals(loadmodel->brushq1.nodes);
+ Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes);
Mod_Q1BSP_FinalizePortals();
}
-static void Mod_Q1BSP_BuildSurfaceNeighbors(msurface_t *surfaces, int numsurfaces, mempool_t *mempool)
-{
-#if 0
- int surfnum, vertnum, vertnum2, snum, vnum, vnum2;
- msurface_t *surf, *s;
- float *v0, *v1, *v2, *v3;
- for (surf = surfaces, surfnum = 0;surfnum < numsurfaces;surf++, surfnum++)
- surf->neighborsurfaces = Mem_Alloc(mempool, surf->poly_numverts * sizeof(msurface_t *));
- for (surf = surfaces, surfnum = 0;surfnum < numsurfaces;surf++, surfnum++)
- {
- for (vertnum = surf->poly_numverts - 1, vertnum2 = 0, v0 = surf->poly_verts + (surf->poly_numverts - 1) * 3, v1 = surf->poly_verts;vertnum2 < surf->poly_numverts;vertnum = vertnum2, vertnum2++, v0 = v1, v1 += 3)
- {
- if (surf->neighborsurfaces[vertnum])
- continue;
- surf->neighborsurfaces[vertnum] = NULL;
- for (s = surfaces, snum = 0;snum < numsurfaces;s++, snum++)
- {
- if (s->poly_mins[0] > (surf->poly_maxs[0] + 1) || s->poly_maxs[0] < (surf->poly_mins[0] - 1)
- || s->poly_mins[1] > (surf->poly_maxs[1] + 1) || s->poly_maxs[1] < (surf->poly_mins[1] - 1)
- || s->poly_mins[2] > (surf->poly_maxs[2] + 1) || s->poly_maxs[2] < (surf->poly_mins[2] - 1)
- || s == surf)
- continue;
- for (vnum = 0;vnum < s->poly_numverts;vnum++)
- if (s->neighborsurfaces[vnum] == surf)
- break;
- if (vnum < s->poly_numverts)
- continue;
- for (vnum = s->poly_numverts - 1, vnum2 = 0, v2 = s->poly_verts + (s->poly_numverts - 1) * 3, v3 = s->poly_verts;vnum2 < s->poly_numverts;vnum = vnum2, vnum2++, v2 = v3, v3 += 3)
- {
- if (s->neighborsurfaces[vnum] == NULL
- && ((v0[0] == v2[0] && v0[1] == v2[1] && v0[2] == v2[2] && v1[0] == v3[0] && v1[1] == v3[1] && v1[2] == v3[2])
- || (v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2] && v0[0] == v3[0] && v0[1] == v3[1] && v0[2] == v3[2])))
- {
- surf->neighborsurfaces[vertnum] = s;
- s->neighborsurfaces[vnum] = surf;
- break;
- }
- }
- if (vnum < s->poly_numverts)
- break;
- }
- }
- }
-#endif
-}
-
static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *model)
{
int i, j, stylecounts[256], totalcount, remapstyles[256];
- msurface_t *surf;
+ msurface_t *surface;
memset(stylecounts, 0, sizeof(stylecounts));
- for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
+ for (i = 0;i < model->nummodelsurfaces;i++)
{
- surf = model->brushq1.surfaces + model->brushq1.firstmodelsurface + i;
+ surface = model->brush.data_surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
- stylecounts[surf->styles[j]]++;
+ stylecounts[surface->styles[j]]++;
}
totalcount = 0;
model->brushq1.light_styles = 0;
model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
j += stylecounts[model->brushq1.light_style[i]] + 1;
}
- for (i = 0;i < model->brushq1.nummodelsurfaces;i++)
+ for (i = 0;i < model->nummodelsurfaces;i++)
{
- surf = model->brushq1.surfaces + model->brushq1.firstmodelsurface + i;
+ surface = model->brush.data_surfaces + model->firstmodelsurface + i;
for (j = 0;j < MAXLIGHTMAPS;j++)
- if (surf->styles[j] != 255)
- *model->brushq1.light_styleupdatechains[remapstyles[surf->styles[j]]]++ = surf;
+ if (surface->styles[j] != 255)
+ *model->brushq1.light_styleupdatechains[remapstyles[surface->styles[j]]]++ = surface;
}
j = 0;
for (i = 0;i < model->brushq1.light_styles;i++)
}
}
-static void Mod_Q1BSP_BuildPVSTextureChains(model_t *model)
+//Returns PVS data for a given point
+//(note: can return NULL)
+static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
{
- int i, j;
- for (i = 0;i < model->brushq1.numtextures;i++)
- model->brushq1.pvstexturechainslength[i] = 0;
- for (i = 0, j = model->brushq1.firstmodelsurface;i < model->brushq1.nummodelsurfaces;i++, j++)
- {
- if (model->brushq1.surfacepvsframes[j] == model->brushq1.pvsframecount)
- {
- model->brushq1.pvssurflist[model->brushq1.pvssurflistlength++] = j;
- model->brushq1.pvstexturechainslength[model->brushq1.surfaces[j].texinfo->texture->number]++;
- }
- }
- for (i = 0, j = 0;i < model->brushq1.numtextures;i++)
- {
- if (model->brushq1.pvstexturechainslength[i])
- {
- model->brushq1.pvstexturechains[i] = model->brushq1.pvstexturechainsbuffer + j;
- j += model->brushq1.pvstexturechainslength[i] + 1;
- }
- else
- model->brushq1.pvstexturechains[i] = NULL;
- }
- for (i = 0, j = model->brushq1.firstmodelsurface;i < model->brushq1.nummodelsurfaces;i++, j++)
- if (model->brushq1.surfacepvsframes[j] == model->brushq1.pvsframecount)
- *model->brushq1.pvstexturechains[model->brushq1.surfaces[j].texinfo->texture->number]++ = model->brushq1.surfaces + j;
- for (i = 0;i < model->brushq1.numtextures;i++)
- {
- if (model->brushq1.pvstexturechainslength[i])
- {
- *model->brushq1.pvstexturechains[i] = NULL;
- model->brushq1.pvstexturechains[i] -= model->brushq1.pvstexturechainslength[i];
- }
- }
+ mnode_t *node;
+ Mod_CheckLoaded(model);
+ node = model->brush.data_nodes;
+ while (node->plane)
+ node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
+ if (((mleaf_t *)node)->clusterindex >= 0)
+ return model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
+ else
+ return NULL;
}
static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbytes, mnode_t *node)
{
- int i;
- float d;
-
- while (node->contents >= 0)
+ while (node->plane)
{
- d = PlaneDiff(org, node->plane);
+ float d = PlaneDiff(org, node->plane);
if (d > radius)
node = node->children[0];
else if (d < -radius)
node = node->children[1];
}
}
- // FIXME: code!
- // if this is a leaf, accumulate the pvs bits
- if (node->contents != CONTENTS_SOLID && ((mleaf_t *)node)->pvsdata)
+ // if this leaf is in a cluster, accumulate the pvs bits
+ if (((mleaf_t *)node)->clusterindex >= 0)
+ {
+ int i;
+ qbyte *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
for (i = 0;i < pvsbytes;i++)
- pvsbuffer[i] |= ((mleaf_t *)node)->pvsdata[i];
+ pvsbuffer[i] |= pvs[i];
+ }
}
//Calculates a PVS that is the inclusive or of all leafs within radius pixels
//of the given point.
static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
{
- int bytes = ((model->brushq1.numleafs - 1) + 7) >> 3;
+ int bytes = model->brush.num_pvsclusterbytes;
bytes = min(bytes, pvsbufferlength);
+ if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org))
+ {
+ memset(pvsbuffer, 0xFF, bytes);
+ return bytes;
+ }
memset(pvsbuffer, 0, bytes);
- Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brushq1.nodes);
+ Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes);
return bytes;
}
-//Returns PVS data for a given point
-//(note: always returns valid data, never NULL)
-static qbyte *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
-{
- mnode_t *node;
- Mod_CheckLoaded(model);
- // LordHavoc: modified to start at first clip node,
- // in other words: first node of the (sub)model
- node = model->brushq1.nodes + model->brushq1.hulls[0].firstclipnode;
- while (node->contents == 0)
- node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
- return ((mleaf_t *)node)->pvsdata;
-}
-
static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
{
vec3_t size;
VectorAdd(inmins, hull->clip_size, outmaxs);
}
-extern void R_Model_Brush_DrawSky(entity_render_t *ent);
-extern void R_Model_Brush_Draw(entity_render_t *ent);
-extern void R_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius);
-extern void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
+extern void R_Q1BSP_DrawSky(entity_render_t *ent);
+extern void R_Q1BSP_Draw(entity_render_t *ent);
+extern void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outclusterlist, qbyte *outclusterpvs, int *outnumclusterspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer);
+extern void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist, const vec3_t lightmins, const vec3_t lightmaxs);
+extern void R_Q1BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int numsurfaces, const int *surfacelist);
void Mod_Q1BSP_Load(model_t *mod, void *buffer)
{
int i, j, k;
dheader_t *header;
dmodel_t *bm;
mempool_t *mainmempool;
- char *loadname;
- model_t *originalloadmodel;
float dist, modelyawradius, modelradius, *vec;
- msurface_t *surf;
+ msurface_t *surface;
+ int numshadowmeshtriangles;
- mod->type = mod_brush;
+ mod->type = mod_brushq1;
header = (dheader_t *)buffer;
mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
+ mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
mod->brushq1.PointInLeaf = Mod_Q1BSP_PointInLeaf;
- mod->brushq1.BuildPVSTextureChains = Mod_Q1BSP_BuildPVSTextureChains;
if (loadmodel->isworldmodel)
- {
Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
// swap all the lumps
mod_base = (qbyte *)header;
- for (i = 0;i < (int) sizeof(dheader_t) / 4;i++)
- ((int *)header)[i] = LittleLong(((int *)header)[i]);
+ header->version = LittleLong(header->version);
+ for (i = 0;i < HEADER_LUMPS;i++)
+ {
+ header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+ header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+ }
// load into heap
Mod_Q1BSP_LoadPlanes(&header->lumps[LUMP_PLANES]);
Mod_Q1BSP_LoadTexinfo(&header->lumps[LUMP_TEXINFO]);
Mod_Q1BSP_LoadFaces(&header->lumps[LUMP_FACES]);
- Mod_Q1BSP_LoadMarksurfaces(&header->lumps[LUMP_MARKSURFACES]);
+ Mod_Q1BSP_LoadLeaffaces(&header->lumps[LUMP_MARKSURFACES]);
Mod_Q1BSP_LoadVisibility(&header->lumps[LUMP_VISIBILITY]);
+ // load submodels before leafs because they contain the number of vis leafs
+ Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS]);
Mod_Q1BSP_LoadLeafs(&header->lumps[LUMP_LEAFS]);
Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]);
Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES]);
- Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS]);
+
+ if (!mod->brushq1.lightdata)
+ mod->brush.LightPoint = NULL;
if (mod->brushq1.data_compressedpvs)
Mem_Free(mod->brushq1.data_compressedpvs);
Mod_Q1BSP_MakeHull0();
Mod_Q1BSP_MakePortals();
- if (developer.integer)
- Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->brushq1.numsurfaces, loadmodel->brushq1.numnodes, loadmodel->brushq1.numleafs, loadmodel->brushq1.numleafs - 1, loadmodel->brushq1.numportals);
-
mod->numframes = 2; // regular and alternate animation
+ mod->numskins = 1;
mainmempool = mod->mempool;
- loadname = mod->name;
Mod_Q1BSP_LoadLightList();
- originalloadmodel = loadmodel;
-//
-// set up the submodels(FIXME: this is confusing)
-//
+ // make a single combined shadow mesh to allow optimized shadow volume creation
+ numshadowmeshtriangles = 0;
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
+ {
+ surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
+ numshadowmeshtriangles += surface->mesh.num_triangles;
+ }
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
+ Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, surface->mesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->mesh.num_triangles, surface->mesh.data_element3i);
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
+ Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
+
+ if (loadmodel->brush.numsubmodels)
+ loadmodel->brush.submodels = Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
+
+ // LordHavoc: to clear the fog around the original quake submodel code, I
+ // will explain:
+ // first of all, some background info on the submodels:
+ // model 0 is the map model (the world, named maps/e1m1.bsp for example)
+ // model 1 and higher are submodels (doors and the like, named *1, *2, etc)
+ // now the weird for loop itself:
+ // the loop functions in an odd way, on each iteration it sets up the
+ // current 'mod' model (which despite the confusing code IS the model of
+ // the number i), at the end of the loop it duplicates the model to become
+ // the next submodel, and loops back to set up the new submodel.
+
+ // LordHavoc: now the explanation of my sane way (which works identically):
+ // set up the world model, then on each submodel copy from the world model
+ // and set up the submodel with the respective model info.
for (i = 0;i < mod->brush.numsubmodels;i++)
{
+ // LordHavoc: this code was originally at the end of this loop, but
+ // has been transformed to something more readable at the start here.
+
+ if (i > 0)
+ {
+ char name[10];
+ // LordHavoc: only register submodels if it is the world
+ // (prevents external bsp models from replacing world submodels with
+ // their own)
+ if (!loadmodel->isworldmodel)
+ continue;
+ // duplicate the basic information
+ sprintf(name, "*%i", i);
+ mod = Mod_FindName(name);
+ // copy the base model to this one
+ *mod = *loadmodel;
+ // rename the clone back to its proper name
+ strcpy(mod->name, name);
+ // textures and memory belong to the main model
+ mod->texturepool = NULL;
+ mod->mempool = NULL;
+ }
+
+ mod->brush.submodel = i;
+
+ if (loadmodel->brush.submodels)
+ loadmodel->brush.submodels[i] = mod;
+
bm = &mod->brushq1.submodels[i];
mod->brushq1.hulls[0].firstclipnode = bm->headnode[0];
mod->brushq1.hulls[j].lastclipnode = mod->brushq1.numclipnodes - 1;
}
- mod->brushq1.firstmodelsurface = bm->firstface;
- mod->brushq1.nummodelsurfaces = bm->numfaces;
+ mod->firstmodelsurface = bm->firstface;
+ mod->nummodelsurfaces = bm->numfaces;
+
+ // make the model surface list (used by shadowing/lighting)
+ mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ mod->surfacelist[j] = mod->firstmodelsurface + j;
// this gets altered below if sky is used
mod->DrawSky = NULL;
- mod->Draw = R_Model_Brush_Draw;
- mod->DrawShadowVolume = R_Model_Brush_DrawShadowVolume;
- mod->DrawLight = R_Model_Brush_DrawLight;
- mod->brushq1.pvstexturechains = Mem_Alloc(originalloadmodel->mempool, mod->brushq1.numtextures * sizeof(msurface_t **));
- mod->brushq1.pvstexturechainsbuffer = Mem_Alloc(originalloadmodel->mempool,(mod->brushq1.nummodelsurfaces + mod->brushq1.numtextures) * sizeof(msurface_t *));
- mod->brushq1.pvstexturechainslength = Mem_Alloc(originalloadmodel->mempool, mod->brushq1.numtextures * sizeof(int));
- Mod_Q1BSP_BuildPVSTextureChains(mod);
- Mod_Q1BSP_BuildLightmapUpdateChains(originalloadmodel->mempool, mod);
- if (mod->brushq1.nummodelsurfaces)
+ mod->Draw = R_Q1BSP_Draw;
+ mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+ mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ mod->DrawLight = R_Q1BSP_DrawLight;
+ if (i != 0)
+ {
+ mod->brush.GetPVS = NULL;
+ mod->brush.FatPVS = NULL;
+ mod->brush.BoxTouchingPVS = NULL;
+ mod->brush.BoxTouchingVisibleLeafs = NULL;
+ mod->brush.LightPoint = NULL;
+ mod->brush.AmbientSoundLevelsForPoint = NULL;
+ }
+ Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod);
+ if (mod->nummodelsurfaces)
{
// LordHavoc: calculate bmodel bounding box rather than trusting what it says
mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
modelyawradius = 0;
modelradius = 0;
- for (j = 0, surf = &mod->brushq1.surfaces[mod->brushq1.firstmodelsurface];j < mod->brushq1.nummodelsurfaces;j++, surf++)
+ for (j = 0, surface = &mod->brush.data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
{
// we only need to have a drawsky function if it is used(usually only on world model)
- if (surf->texinfo->texture->shader == &Cshader_sky)
- mod->DrawSky = R_Model_Brush_DrawSky;
- // LordHavoc: submodels always clip, even if water
- if (mod->brush.numsubmodels - 1)
- surf->flags |= SURF_SOLIDCLIP;
+ if (surface->texture->basematerialflags & MATERIALFLAG_SKY)
+ mod->DrawSky = R_Q1BSP_DrawSky;
// calculate bounding shapes
- for (k = 0, vec = surf->mesh.data_vertex3f;k < surf->mesh.num_vertices;k++, vec += 3)
+ for (k = 0, vec = surface->mesh.data_vertex3f;k < surface->mesh.num_vertices;k++, vec += 3)
{
if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
else
{
// LordHavoc: empty submodel(lacrima.bsp has such a glitch)
- Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadname);
- }
- Mod_Q1BSP_BuildSurfaceNeighbors(mod->brushq1.surfaces + mod->brushq1.firstmodelsurface, mod->brushq1.nummodelsurfaces, originalloadmodel->mempool);
-
- mod->brushq1.visleafs = bm->visleafs;
-
- // LordHavoc: only register submodels if it is the world
- // (prevents bsp models from replacing world submodels)
- if (loadmodel->isworldmodel && i < (mod->brush.numsubmodels - 1))
- {
- char name[10];
- // duplicate the basic information
- sprintf(name, "*%i", i+1);
- loadmodel = Mod_FindName(name);
- *loadmodel = *mod;
- strcpy(loadmodel->name, name);
- // textures and memory belong to the main model
- loadmodel->texturepool = NULL;
- loadmodel->mempool = NULL;
- mod = loadmodel;
+ Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
}
+ //mod->brushq1.num_visleafs = bm->visleafs;
}
- loadmodel = originalloadmodel;
+ Mod_Q1BSP_LoadMapBrushes();
+
//Mod_Q1BSP_ProcessLightList();
+
+ if (developer.integer)
+ Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->brush.num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brushq1.submodels[i].visleafs, loadmodel->brush.num_portals);
}
static void Mod_Q2BSP_LoadEntities(lump_t *l)
Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
mod->brush.ishlbsp = false;
if (loadmodel->isworldmodel)
- {
Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
mod_base = (qbyte *)header;
static void Mod_Q3BSP_LoadTextures(lump_t *l)
{
q3dtexture_t *in;
- q3mtexture_t *out;
+ texture_t *out;
int i, count;
int j, c;
fssearch_t *search;
char *f;
const char *text;
- int flags;
+ int flags, flags2, numparameters, passnumber;
char shadername[Q3PATHLENGTH];
+ char sky[Q3PATHLENGTH];
+ char firstpasstexturename[Q3PATHLENGTH];
+ char parameter[4][Q3PATHLENGTH];
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_textures = out;
- loadmodel->brushq3.num_textures = count;
+ loadmodel->brush.data_textures = out;
+ loadmodel->brush.num_textures = count;
for (i = 0;i < count;i++, in++, out++)
{
- out->number = i;
strlcpy (out->name, in->name, sizeof (out->name));
out->surfaceflags = LittleLong(in->surfaceflags);
- out->nativecontents = LittleLong(in->contents);
- out->supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, out->nativecontents);
- Mod_LoadSkinFrame(&out->skin, out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE, false, true, true);
+ out->supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in->contents));
out->surfaceparms = -1;
}
{
for (i = 0;i < search->numfilenames;i++)
{
- if ((f = FS_LoadFile(search->filenames[i], false)))
+ if ((f = FS_LoadFile(search->filenames[i], tempmempool, false)))
{
text = f;
while (COM_ParseToken(&text, false))
{
- snprintf(shadername, sizeof(shadername), "%s", com_token);
+ strlcpy (shadername, com_token, sizeof (shadername));
flags = 0;
- if (COM_ParseToken(&text, false) && !strcmp(com_token, "{"))
+ flags2 = 0;
+ sky[0] = 0;
+ passnumber = 0;
+ firstpasstexturename[0] = 0;
+ if (COM_ParseToken(&text, false) && !strcasecmp(com_token, "{"))
{
while (COM_ParseToken(&text, false))
{
- if (!strcmp(com_token, "}"))
+ if (!strcasecmp(com_token, "}"))
break;
- else if (!strcmp(com_token, "{"))
+ else if (!strcasecmp(com_token, "{"))
{
while (COM_ParseToken(&text, false))
{
- if (!strcmp(com_token, "}"))
+ if (!strcasecmp(com_token, "}"))
+ break;
+ if (!strcasecmp(com_token, "\n"))
+ continue;
+ numparameters = 0;
+ for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
+ {
+ if (j < 4)
+ {
+ strlcpy(parameter[j], com_token, sizeof(parameter[j]));
+ numparameters = j + 1;
+ }
+ if (!COM_ParseToken(&text, true))
+ break;
+ }
+ if (developer.integer >= 2)
+ {
+ Con_Printf("%s %i: ", shadername, passnumber);
+ for (j = 0;j < numparameters;j++)
+ Con_Printf(" %s", parameter[j]);
+ Con_Print("\n");
+ }
+ if (passnumber == 0 && numparameters >= 1)
+ {
+ if (!strcasecmp(parameter[0], "blendfunc"))
+ {
+ if (numparameters == 2 && !strcasecmp(parameter[1], "add"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ else if (numparameters == 3 && !strcasecmp(parameter[1], "gl_one") && !strcasecmp(parameter[2], "gl_one"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ else if (numparameters == 3 && !strcasecmp(parameter[1], "gl_src_alpha") && !strcasecmp(parameter[2], "gl_one"))
+ flags2 |= Q3TEXTUREFLAG_ADDITIVE;
+ }
+ else if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap")))
+ strlcpy(firstpasstexturename, parameter[1], sizeof(firstpasstexturename));
+ else if (numparameters >= 3 && !strcasecmp(parameter[0], "animmap"))
+ strlcpy(firstpasstexturename, parameter[2], sizeof(firstpasstexturename));
+ }
+ if (!strcasecmp(parameter[0], "alphafunc"))
+ flags2 |= Q3TEXTUREFLAG_ALPHATEST;
+ // break out a level if it was }
+ if (!strcasecmp(com_token, "}"))
break;
}
+ passnumber++;
+ continue;
}
- else if (!strcmp(com_token, "surfaceparm"))
+ numparameters = 0;
+ for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
{
- if (COM_ParseToken(&text, true) && strcmp(com_token, "\n"))
+ if (j < 4)
{
- if (!strcmp(com_token, "alphashadow"))
- flags |= Q3SURFACEPARM_ALPHASHADOW;
- else if (!strcmp(com_token, "areaportal"))
- flags |= Q3SURFACEPARM_AREAPORTAL;
- else if (!strcmp(com_token, "clusterportal"))
- flags |= Q3SURFACEPARM_CLUSTERPORTAL;
- else if (!strcmp(com_token, "detail"))
- flags |= Q3SURFACEPARM_DETAIL;
- else if (!strcmp(com_token, "donotenter"))
- flags |= Q3SURFACEPARM_DONOTENTER;
- else if (!strcmp(com_token, "fog"))
- flags |= Q3SURFACEPARM_FOG;
- else if (!strcmp(com_token, "lava"))
- flags |= Q3SURFACEPARM_LAVA;
- else if (!strcmp(com_token, "lightfilter"))
- flags |= Q3SURFACEPARM_LIGHTFILTER;
- else if (!strcmp(com_token, "metalsteps"))
- flags |= Q3SURFACEPARM_METALSTEPS;
- else if (!strcmp(com_token, "nodamage"))
- flags |= Q3SURFACEPARM_NODAMAGE;
- else if (!strcmp(com_token, "nodlight"))
- flags |= Q3SURFACEPARM_NODLIGHT;
- else if (!strcmp(com_token, "nodraw"))
- flags |= Q3SURFACEPARM_NODRAW;
- else if (!strcmp(com_token, "nodrop"))
- flags |= Q3SURFACEPARM_NODROP;
- else if (!strcmp(com_token, "noimpact"))
- flags |= Q3SURFACEPARM_NOIMPACT;
- else if (!strcmp(com_token, "nolightmap"))
- flags |= Q3SURFACEPARM_NOLIGHTMAP;
- else if (!strcmp(com_token, "nomarks"))
- flags |= Q3SURFACEPARM_NOMARKS;
- else if (!strcmp(com_token, "nomipmaps"))
- flags |= Q3SURFACEPARM_NOMIPMAPS;
- else if (!strcmp(com_token, "nonsolid"))
- flags |= Q3SURFACEPARM_NONSOLID;
- else if (!strcmp(com_token, "origin"))
- flags |= Q3SURFACEPARM_ORIGIN;
- else if (!strcmp(com_token, "playerclip"))
- flags |= Q3SURFACEPARM_PLAYERCLIP;
- else if (!strcmp(com_token, "sky"))
- flags |= Q3SURFACEPARM_SKY;
- else if (!strcmp(com_token, "slick"))
- flags |= Q3SURFACEPARM_SLICK;
- else if (!strcmp(com_token, "slime"))
- flags |= Q3SURFACEPARM_SLIME;
- else if (!strcmp(com_token, "structural"))
- flags |= Q3SURFACEPARM_STRUCTURAL;
- else if (!strcmp(com_token, "trans"))
- flags |= Q3SURFACEPARM_TRANS;
- else if (!strcmp(com_token, "water"))
- flags |= Q3SURFACEPARM_WATER;
- else
- Con_Printf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[i], com_token);
- if (!COM_ParseToken(&text, true) || strcmp(com_token, "\n"))
- {
- Con_Printf("%s parsing error: surfaceparm only takes one parameter.\n", search->filenames[i]);
- goto parseerror;
- }
+ strlcpy(parameter[j], com_token, sizeof(parameter[j]));
+ numparameters = j + 1;
}
+ if (!COM_ParseToken(&text, true))
+ break;
+ }
+ if (i == 0 && !strcasecmp(com_token, "}"))
+ break;
+ if (developer.integer >= 2)
+ {
+ Con_Printf("%s: ", shadername);
+ for (j = 0;j < numparameters;j++)
+ Con_Printf(" %s", parameter[j]);
+ Con_Print("\n");
+ }
+ if (numparameters < 1)
+ continue;
+ if (!strcasecmp(parameter[0], "surfaceparm") && numparameters >= 2)
+ {
+ if (!strcasecmp(parameter[1], "alphashadow"))
+ flags |= Q3SURFACEPARM_ALPHASHADOW;
+ else if (!strcasecmp(parameter[1], "areaportal"))
+ flags |= Q3SURFACEPARM_AREAPORTAL;
+ else if (!strcasecmp(parameter[1], "clusterportal"))
+ flags |= Q3SURFACEPARM_CLUSTERPORTAL;
+ else if (!strcasecmp(parameter[1], "detail"))
+ flags |= Q3SURFACEPARM_DETAIL;
+ else if (!strcasecmp(parameter[1], "donotenter"))
+ flags |= Q3SURFACEPARM_DONOTENTER;
+ else if (!strcasecmp(parameter[1], "fog"))
+ flags |= Q3SURFACEPARM_FOG;
+ else if (!strcasecmp(parameter[1], "lava"))
+ flags |= Q3SURFACEPARM_LAVA;
+ else if (!strcasecmp(parameter[1], "lightfilter"))
+ flags |= Q3SURFACEPARM_LIGHTFILTER;
+ else if (!strcasecmp(parameter[1], "metalsteps"))
+ flags |= Q3SURFACEPARM_METALSTEPS;
+ else if (!strcasecmp(parameter[1], "nodamage"))
+ flags |= Q3SURFACEPARM_NODAMAGE;
+ else if (!strcasecmp(parameter[1], "nodlight"))
+ flags |= Q3SURFACEPARM_NODLIGHT;
+ else if (!strcasecmp(parameter[1], "nodraw"))
+ flags |= Q3SURFACEPARM_NODRAW;
+ else if (!strcasecmp(parameter[1], "nodrop"))
+ flags |= Q3SURFACEPARM_NODROP;
+ else if (!strcasecmp(parameter[1], "noimpact"))
+ flags |= Q3SURFACEPARM_NOIMPACT;
+ else if (!strcasecmp(parameter[1], "nolightmap"))
+ flags |= Q3SURFACEPARM_NOLIGHTMAP;
+ else if (!strcasecmp(parameter[1], "nomarks"))
+ flags |= Q3SURFACEPARM_NOMARKS;
+ else if (!strcasecmp(parameter[1], "nomipmaps"))
+ flags |= Q3SURFACEPARM_NOMIPMAPS;
+ else if (!strcasecmp(parameter[1], "nonsolid"))
+ flags |= Q3SURFACEPARM_NONSOLID;
+ else if (!strcasecmp(parameter[1], "origin"))
+ flags |= Q3SURFACEPARM_ORIGIN;
+ else if (!strcasecmp(parameter[1], "playerclip"))
+ flags |= Q3SURFACEPARM_PLAYERCLIP;
+ else if (!strcasecmp(parameter[1], "sky"))
+ flags |= Q3SURFACEPARM_SKY;
+ else if (!strcasecmp(parameter[1], "slick"))
+ flags |= Q3SURFACEPARM_SLICK;
+ else if (!strcasecmp(parameter[1], "slime"))
+ flags |= Q3SURFACEPARM_SLIME;
+ else if (!strcasecmp(parameter[1], "structural"))
+ flags |= Q3SURFACEPARM_STRUCTURAL;
+ else if (!strcasecmp(parameter[1], "trans"))
+ flags |= Q3SURFACEPARM_TRANS;
+ else if (!strcasecmp(parameter[1], "water"))
+ flags |= Q3SURFACEPARM_WATER;
+ else if (!strcasecmp(parameter[1], "pointlight"))
+ flags |= Q3SURFACEPARM_POINTLIGHT;
else
- {
- Con_Printf("%s parsing error: surfaceparm expects a parameter.\n", search->filenames[i]);
- goto parseerror;
- }
+ Con_Printf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[i], parameter[1]);
}
- else
+ else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
+ strlcpy(sky, parameter[1], sizeof(sky));
+ else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2)
{
- // look for linebreak or }
- while(COM_ParseToken(&text, true) && strcmp(com_token, "\n") && strcmp(com_token, "}"));
- // break out to top level if it was }
- if (!strcmp(com_token, "}"))
- break;
+ if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-"))
+ strlcpy(sky, parameter[1], sizeof(sky));
+ }
+ else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2)
+ {
+ if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided"))
+ flags2 |= Q3TEXTUREFLAG_TWOSIDED;
+ }
+ else if (!strcasecmp(parameter[0], "nomipmaps"))
+ flags2 |= Q3TEXTUREFLAG_NOMIPMAPS;
+ else if (!strcasecmp(parameter[0], "nopicmip"))
+ flags2 |= Q3TEXTUREFLAG_NOPICMIP;
+ else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
+ {
+ if (!strcasecmp(parameter[1], "autosprite") && numparameters == 2)
+ flags2 |= Q3TEXTUREFLAG_AUTOSPRITE;
+ if (!strcasecmp(parameter[1], "autosprite2") && numparameters == 2)
+ flags2 |= Q3TEXTUREFLAG_AUTOSPRITE2;
}
}
+ // force transparent render path for a number of odd
+ // shader effects to avoid bogging down the normal
+ // render path unnecessarily
+ if (flags2 & (Q3TEXTUREFLAG_ADDITIVE | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2 | Q3TEXTUREFLAG_ALPHATEST))
+ flags |= Q3SURFACEPARM_TRANS;
// add shader to list (shadername and flags)
// actually here we just poke into the texture settings
- for (j = 0, out = loadmodel->brushq3.data_textures;j < loadmodel->brushq3.num_textures;j++, out++)
- if (!strcmp(out->name, shadername))
+ for (j = 0, out = loadmodel->brush.data_textures;j < loadmodel->brush.num_textures;j++, out++)
+ {
+ if (!strcasecmp(out->name, shadername))
+ {
out->surfaceparms = flags;
+ out->textureflags = flags2;
+ out->basematerialflags = 0;
+ if (out->surfaceparms & Q3SURFACEPARM_NODRAW)
+ out->basematerialflags |= MATERIALFLAG_NODRAW;
+ else if (out->surfaceparms & Q3SURFACEPARM_SKY)
+ out->basematerialflags |= MATERIALFLAG_SKY;
+ else if (out->surfaceparms & Q3SURFACEPARM_LAVA)
+ out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_FULLBRIGHT;
+ else if (out->surfaceparms & Q3SURFACEPARM_SLIME)
+ out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_WATERALPHA;
+ else if (out->surfaceparms & Q3SURFACEPARM_WATER)
+ out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_WATERALPHA;
+ else
+ out->basematerialflags |= MATERIALFLAG_WALL;
+ if (out->surfaceparms & Q3SURFACEPARM_TRANS)
+ out->basematerialflags |= MATERIALFLAG_TRANSPARENT;
+ if (out->textureflags & Q3TEXTUREFLAG_ADDITIVE)
+ out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_TRANSPARENT;
+ strlcpy(out->firstpasstexturename, firstpasstexturename, sizeof(out->firstpasstexturename));
+ if ((flags & Q3SURFACEPARM_SKY) && sky[0])
+ {
+ // quake3 seems to append a _ to the skybox name, so this must do so as well
+ dpsnprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", sky);
+ }
+ }
+ }
}
else
{
}
c = 0;
- for (j = 0, out = loadmodel->brushq3.data_textures;j < loadmodel->brushq3.num_textures;j++, out++)
+ for (j = 0, out = loadmodel->brush.data_textures;j < loadmodel->brush.num_textures;j++, out++)
{
if (out->surfaceparms == -1)
{
c++;
Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name);
out->surfaceparms = 0;
+ if (out->surfaceflags & Q3SURFACEFLAG_NODRAW)
+ out->basematerialflags |= MATERIALFLAG_NODRAW;
+ else if (out->surfaceflags & Q3SURFACEFLAG_SKY)
+ out->basematerialflags |= MATERIALFLAG_SKY;
+ else
+ out->basematerialflags |= MATERIALFLAG_WALL;
// these are defaults
- if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
- || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
- out->surfaceparms |= Q3SURFACEPARM_NODRAW;
- if (!strncmp(out->name, "textures/skies/", 15))
- out->surfaceparms |= Q3SURFACEPARM_SKY;
- if (R_TextureHasAlpha(out->skin.base))
- out->surfaceparms |= Q3SURFACEPARM_TRANS;
+ //if (!strncmp(out->name, "textures/skies/", 15))
+ // out->surfaceparms |= Q3SURFACEPARM_SKY;
+ //if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
+ // || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
+ // out->surfaceparms |= Q3SURFACEPARM_NODRAW;
+ //if (R_TextureHasAlpha(out->skin.base))
+ // out->surfaceparms |= Q3SURFACEPARM_TRANS;
}
- }
- Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
+ if (!Mod_LoadSkinFrame(&out->skin, out->name, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
+ if (!Mod_LoadSkinFrame(&out->skin, out->firstpasstexturename, (((out->textureflags & Q3TEXTUREFLAG_NOMIPMAPS) || (out->surfaceparms & Q3SURFACEPARM_NOMIPMAPS)) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (out->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP), false, false, true))
+ Con_Printf("%s: texture loading for shader \"%s\" failed (first layer \"%s\" not found either)\n", loadmodel->name, out->name, out->firstpasstexturename);
+ if (out->skin.fog)
+ out->basematerialflags |= (MATERIALFLAG_ALPHA | MATERIALFLAG_TRANSPARENT);
+ // no animation
+ out->currentframe = out;
+ }
+ if (c)
+ Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
}
static void Mod_Q3BSP_LoadPlanes(lump_t *l)
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_planes = out;
- loadmodel->brushq3.num_planes = count;
+ loadmodel->brush.data_planes = out;
+ loadmodel->brush.num_planes = count;
for (i = 0;i < count;i++, in++, out++)
{
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_brushsides = out;
- loadmodel->brushq3.num_brushsides = count;
+ loadmodel->brush.data_brushsides = out;
+ loadmodel->brush.num_brushsides = count;
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(in->planeindex);
- if (n < 0 || n >= loadmodel->brushq3.num_planes)
- Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)\n", n, loadmodel->brushq3.num_planes);
- out->plane = loadmodel->brushq3.data_planes + n;
+ if (n < 0 || n >= loadmodel->brush.num_planes)
+ Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)\n", n, loadmodel->brush.num_planes);
+ out->plane = loadmodel->brush.data_planes + n;
n = LittleLong(in->textureindex);
- if (n < 0 || n >= loadmodel->brushq3.num_textures)
- Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)\n", n, loadmodel->brushq3.num_textures);
- out->texture = loadmodel->brushq3.data_textures + n;
+ if (n < 0 || n >= loadmodel->brush.num_textures)
+ Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)\n", n, loadmodel->brush.num_textures);
+ out->texture = loadmodel->brush.data_textures + n;
}
}
q3mbrush_t *out;
int i, j, n, c, count, maxplanes;
mplane_t *planes;
- winding_t *temp1, *temp2;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_brushes = out;
- loadmodel->brushq3.num_brushes = count;
-
- temp1 = Winding_New(64);
- temp2 = Winding_New(64);
+ loadmodel->brush.data_brushes = out;
+ loadmodel->brush.num_brushes = count;
maxplanes = 0;
planes = NULL;
{
n = LittleLong(in->firstbrushside);
c = LittleLong(in->numbrushsides);
- if (n < 0 || n + c > loadmodel->brushq3.num_brushsides)
- Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)\n", n, n + c, loadmodel->brushq3.num_brushsides);
- out->firstbrushside = loadmodel->brushq3.data_brushsides + n;
+ if (n < 0 || n + c > loadmodel->brush.num_brushsides)
+ Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)\n", n, n + c, loadmodel->brush.num_brushsides);
+ out->firstbrushside = loadmodel->brush.data_brushsides + n;
out->numbrushsides = c;
n = LittleLong(in->textureindex);
- if (n < 0 || n >= loadmodel->brushq3.num_textures)
- Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)\n", n, loadmodel->brushq3.num_textures);
- out->texture = loadmodel->brushq3.data_textures + n;
+ if (n < 0 || n >= loadmodel->brush.num_textures)
+ Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)\n", n, loadmodel->brush.num_textures);
+ out->texture = loadmodel->brush.data_textures + n;
// make a list of mplane_t structs to construct a colbrush from
if (maxplanes < out->numbrushsides)
planes[j].dist = out->firstbrushside[j].plane->dist;
}
// make the colbrush from the planes
- out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, temp1, temp2);
+ out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
}
if (planes)
Mem_Free(planes);
- Winding_Free(temp1);
- Winding_Free(temp2);
}
static void Mod_Q3BSP_LoadEffects(lump_t *l)
{
q3deffect_t *in;
- q3meffect_t *out;
+ q3deffect_t *out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
{
strlcpy (out->shadername, in->shadername, sizeof (out->shadername));
n = LittleLong(in->brushindex);
- if (n < 0 || n >= loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes)\n", n, loadmodel->brushq3.num_brushes);
- out->brush = loadmodel->brushq3.data_brushes + n;
+ if (n < 0 || n >= loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
+ out->brushindex = n;
out->unknown = LittleLong(in->unknown);
}
}
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadVertices: funny lump size in %s",loadmodel->name);
loadmodel->brushq3.num_vertices = count = l->filelen / sizeof(*in);
- loadmodel->brushq3.data_vertex3f = Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 3 + 3 + 3 + 4)));
+ loadmodel->brushq3.data_vertex3f = Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 2 + 2 + 4)));
loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_vertex3f + count * 3;
loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + count * 2;
- loadmodel->brushq3.data_svector3f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
- loadmodel->brushq3.data_tvector3f = loadmodel->brushq3.data_svector3f + count * 3;
- loadmodel->brushq3.data_normal3f = loadmodel->brushq3.data_tvector3f + count * 3;
- loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_normal3f + count * 3;
+ loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
for (i = 0;i < count;i++, in++)
{
loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 0] = LittleFloat(in->lightmap2f[0]);
loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 1] = LittleFloat(in->lightmap2f[1]);
// svector/tvector are calculated later in face loading
- loadmodel->brushq3.data_svector3f[i * 3 + 0] = 0;
- loadmodel->brushq3.data_svector3f[i * 3 + 1] = 0;
- loadmodel->brushq3.data_svector3f[i * 3 + 2] = 0;
- loadmodel->brushq3.data_tvector3f[i * 3 + 0] = 0;
- loadmodel->brushq3.data_tvector3f[i * 3 + 1] = 0;
- loadmodel->brushq3.data_tvector3f[i * 3 + 2] = 0;
- loadmodel->brushq3.data_normal3f[i * 3 + 0] = LittleFloat(in->normal3f[0]);
- loadmodel->brushq3.data_normal3f[i * 3 + 1] = LittleFloat(in->normal3f[1]);
- loadmodel->brushq3.data_normal3f[i * 3 + 2] = LittleFloat(in->normal3f[2]);
loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f);
loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f);
loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f);
if (l->filelen % sizeof(int[3]))
Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
count = l->filelen / sizeof(*in);
- out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out) * 2);
+ out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.num_triangles = count / 3;
loadmodel->brushq3.data_element3i = out;
- loadmodel->brushq3.data_neighbor3i = out + count;
for (i = 0;i < count;i++, in++, out++)
{
static void Mod_Q3BSP_LoadFaces(lump_t *l)
{
- q3dface_t *in;
- q3mface_t *out;
- int i, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xlevel, ylevel, row0, row1, x, y, *e, finalvertices, finaltriangles;
+ q3dface_t *in, *oldin;
+ msurface_t *out, *oldout;
+ int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshnum, meshvertices, meshtriangles, numvertices, numtriangles;
//int *originalelement3i;
//int *originalneighbor3i;
float *originalvertex3f;
float *originaltexcoordtexture2f;
float *originaltexcoordlightmap2f;
float *v;
+ surfmesh_t *mesh, *tempmeshlist[1024];
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_faces = out;
- loadmodel->brushq3.num_faces = count;
+ loadmodel->brush.data_surfaces = out;
+ loadmodel->brush.num_surfaces = count;
- for (i = 0;i < count;i++, in++, out++)
- {
- // check face type first
- out->type = LittleLong(in->type);
- if (out->type != Q3FACETYPE_POLYGON
- && out->type != Q3FACETYPE_PATCH
- && out->type != Q3FACETYPE_MESH
- && out->type != Q3FACETYPE_FLARE)
+ i = 0;
+ for (meshnum = 0;i < count;meshnum++)
+ {
+ oldi = i;
+ oldin = in;
+ oldout = out;
+ meshvertices = 0;
+ meshtriangles = 0;
+ for (;i < count;i++, in++, out++)
{
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, out->type);
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
- continue;
- }
+ // check face type first
+ type = LittleLong(in->type);
+ if (type != Q3FACETYPE_POLYGON
+ && type != Q3FACETYPE_PATCH
+ && type != Q3FACETYPE_MESH
+ && type != Q3FACETYPE_FLARE)
+ {
+ Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, type);
+ continue;
+ }
- n = LittleLong(in->textureindex);
- if (n < 0 || n >= loadmodel->brushq3.num_textures)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i: invalid textureindex %i (%i textures)\n", i, n, loadmodel->brushq3.num_textures);
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
- continue;
- n = 0;
- }
- out->texture = loadmodel->brushq3.data_textures + n;
- n = LittleLong(in->effectindex);
- if (n < -1 || n >= loadmodel->brushq3.num_effects)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
- n = -1;
- }
- if (n == -1)
- out->effect = NULL;
- else
- out->effect = loadmodel->brushq3.data_effects + n;
- n = LittleLong(in->lightmapindex);
- if (n < -1 || n >= loadmodel->brushq3.num_lightmaps)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps);
- n = -1;
- }
- if (n == -1)
- out->lightmaptexture = NULL;
- else
- out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
+ n = LittleLong(in->textureindex);
+ if (n < 0 || n >= loadmodel->brush.num_textures)
+ {
+ Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: invalid textureindex %i (%i textures)\n", i, n, loadmodel->brush.num_textures);
+ continue;
+ }
+ out->texture = loadmodel->brush.data_textures + n;
+ n = LittleLong(in->effectindex);
+ if (n < -1 || n >= loadmodel->brushq3.num_effects)
+ {
+ if (developer.integer >= 2)
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
+ n = -1;
+ }
+ if (n == -1)
+ out->effect = NULL;
+ else
+ out->effect = loadmodel->brushq3.data_effects + n;
+ n = LittleLong(in->lightmapindex);
+ if (n >= loadmodel->brushq3.num_lightmaps)
+ {
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps);
+ n = -1;
+ }
+ else if (n < 0)
+ n = -1;
+ if (n == -1)
+ out->lightmaptexture = NULL;
+ else
+ out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
- out->firstvertex = LittleLong(in->firstvertex);
- out->num_vertices = LittleLong(in->numvertices);
- out->firstelement = LittleLong(in->firstelement);
- out->num_triangles = LittleLong(in->numelements) / 3;
- if (out->num_triangles * 3 != LittleLong(in->numelements))
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
- continue;
- }
- if (out->firstvertex < 0 || out->firstvertex + out->num_vertices > loadmodel->brushq3.num_vertices)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, out->firstvertex, out->firstvertex + out->num_vertices, loadmodel->brushq3.num_vertices);
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
- continue;
- }
- if (out->firstelement < 0 || out->firstelement + out->num_triangles * 3 > loadmodel->brushq3.num_triangles * 3)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, out->firstelement, out->firstelement + out->num_triangles * 3, loadmodel->brushq3.num_triangles * 3);
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
- continue;
- }
- switch(out->type)
- {
- case Q3FACETYPE_POLYGON:
- case Q3FACETYPE_MESH:
- // no processing necessary
- out->data_vertex3f = loadmodel->brushq3.data_vertex3f + out->firstvertex * 3;
- out->data_texcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + out->firstvertex * 2;
- out->data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + out->firstvertex * 2;
- out->data_svector3f = loadmodel->brushq3.data_svector3f + out->firstvertex * 3;
- out->data_tvector3f = loadmodel->brushq3.data_tvector3f + out->firstvertex * 3;
- out->data_normal3f = loadmodel->brushq3.data_normal3f + out->firstvertex * 3;
- out->data_color4f = loadmodel->brushq3.data_color4f + out->firstvertex * 4;
- out->data_element3i = loadmodel->brushq3.data_element3i + out->firstelement;
- out->data_neighbor3i = loadmodel->brushq3.data_neighbor3i + out->firstelement;
- break;
- case Q3FACETYPE_PATCH:
- patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
- patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
- if (patchsize[0] < 1 || patchsize[1] < 1)
+ firstvertex = LittleLong(in->firstvertex);
+ numvertices = LittleLong(in->numvertices);
+ firstelement = LittleLong(in->firstelement);
+ numtriangles = LittleLong(in->numelements) / 3;
+ if (numtriangles * 3 != LittleLong(in->numelements))
{
- Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid patchsize %ix%i\n", i, out->texture->name, patchsize[0], patchsize[1]);
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0; // error
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
continue;
}
- // convert patch to Q3FACETYPE_MESH
- xlevel = mod_q3bsp_curves_subdivide_level.integer;
- ylevel = mod_q3bsp_curves_subdivide_level.integer;
- finalwidth = ((patchsize[0] - 1) << xlevel) + 1;
- finalheight = ((patchsize[1] - 1) << ylevel) + 1;
- finalvertices = finalwidth * finalheight;
- finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
- originalvertex3f = loadmodel->brushq3.data_vertex3f + out->firstvertex * 3;
- //originalsvector3f = loadmodel->brushq3.data_svector3f + out->firstvertex * 3;
- //originaltvector3f = loadmodel->brushq3.data_tvector3f + out->firstvertex * 3;
- //originalnormal3f = loadmodel->brushq3.data_normal3f + out->firstvertex * 3;
- originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + out->firstvertex * 2;
- originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + out->firstvertex * 2;
- originalcolor4f = loadmodel->brushq3.data_color4f + out->firstvertex * 4;
- //originalelement3i = loadmodel->brushq3.data_element3i + out->firstelement;
- //originalneighbor3i = loadmodel->brushq3.data_neighbor3i + out->firstelement;
- /*
- originalvertex3f = out->data_vertex3f;
- //originalsvector3f = out->data_svector3f;
- //originaltvector3f = out->data_tvector3f;
- //originalnormal3f = out->data_normal3f;
- originalcolor4f = out->data_color4f;
- originaltexcoordtexture2f = out->data_texcoordtexture2f;
- originaltexcoordlightmap2f = out->data_texcoordlightmap2f;
- //originalelement3i = out->data_element3i;
- //originalneighbor3i = out->data_neighbor3i;
- */
- out->data_vertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[20]) * finalvertices);
- out->data_svector3f = out->data_vertex3f + finalvertices * 3;
- out->data_tvector3f = out->data_svector3f + finalvertices * 3;
- out->data_normal3f = out->data_tvector3f + finalvertices * 3;
- out->data_color4f = out->data_normal3f + finalvertices * 3;
- out->data_texcoordtexture2f = out->data_color4f + finalvertices * 4;
- out->data_texcoordlightmap2f = out->data_texcoordtexture2f + finalvertices * 2;
- out->data_element3i = Mem_Alloc(loadmodel->mempool, sizeof(int[6]) * finaltriangles);
- out->data_neighbor3i = out->data_element3i + finaltriangles * 3;
- out->type = Q3FACETYPE_MESH;
- out->firstvertex = -1;
- out->num_vertices = finalvertices;
- out->firstelement = -1;
- out->num_triangles = finaltriangles;
- // generate geometry
- // (note: normals are skipped because they get recalculated)
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_vertex3f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordtexture2f, out->data_texcoordtexture2f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordlightmap2f, out->data_texcoordlightmap2f);
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 4, originalcolor4f, out->data_color4f);
- // generate elements
- e = out->data_element3i;
- for (y = 0;y < finalheight - 1;y++)
+ if (firstvertex < 0 || firstvertex + numvertices > loadmodel->brushq3.num_vertices)
{
- row0 = (y + 0) * finalwidth;
- row1 = (y + 1) * finalwidth;
- for (x = 0;x < finalwidth - 1;x++)
- {
- *e++ = row0;
- *e++ = row1;
- *e++ = row0 + 1;
- *e++ = row1;
- *e++ = row1 + 1;
- *e++ = row0 + 1;
- row0++;
- row1++;
- }
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, firstvertex, firstvertex + numvertices, loadmodel->brushq3.num_vertices);
+ continue;
}
- out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, out->data_element3i, out->data_element3i, out->data_vertex3f);
- if (developer.integer)
+ if (firstelement < 0 || firstelement + numtriangles * 3 > loadmodel->brushq3.num_triangles * 3)
{
- if (out->num_triangles < finaltriangles)
- Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
- else
- Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, firstelement, firstelement + numtriangles * 3, loadmodel->brushq3.num_triangles * 3);
+ continue;
}
- // q3map does not put in collision brushes for curves... ugh
- out->collisions = true;
- break;
- case Q3FACETYPE_FLARE:
- Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
- // don't render it
- out->num_vertices = 0;
- out->num_triangles = 0;
- out->type = 0;
- break;
- }
- for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
- if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
- invalidelements++;
- if (invalidelements)
- {
- Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, texture->nativecontents = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, out->type, out->texture->name, out->texture->surfaceflags, out->texture->nativecontents, out->firstvertex, out->num_vertices, out->firstelement, out->num_triangles * 3);
- for (j = 0;j < out->num_triangles * 3;j++)
+ switch(type)
{
- Con_Printf(" %i", out->data_element3i[j]);
- if (out->data_element3i[j] < 0 || out->data_element3i[j] >= out->num_vertices)
- out->data_element3i[j] = 0;
+ case Q3FACETYPE_POLYGON:
+ case Q3FACETYPE_MESH:
+ // no processing necessary
+ break;
+ case Q3FACETYPE_PATCH:
+ patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
+ patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
+ if (numvertices != (patchsize[0] * patchsize[1]) || patchsize[0] < 3 || patchsize[1] < 3 || !(patchsize[0] & 1) || !(patchsize[1] & 1) || patchsize[0] * patchsize[1] >= min(r_subdivisions_maxvertices.integer, r_subdivisions_collision_maxvertices.integer))
+ {
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid patchsize %ix%i\n", i, out->texture->name, patchsize[0], patchsize[1]);
+ continue;
+ }
+ originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+ // convert patch to Q3FACETYPE_MESH
+ xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
+ ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
+ // bound to user settings
+ xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
+ ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
+ // bound to sanity settings
+ xtess = bound(1, xtess, 1024);
+ ytess = bound(1, ytess, 1024);
+ // bound to user limit on vertices
+ while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
+ {
+ if (xtess > ytess)
+ xtess--;
+ else
+ ytess--;
+ }
+ finalwidth = ((patchsize[0] - 1) * xtess) + 1;
+ finalheight = ((patchsize[1] - 1) * ytess) + 1;
+ numvertices = finalwidth * finalheight;
+ numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+ break;
+ case Q3FACETYPE_FLARE:
+ if (developer.integer >= 2)
+ Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
+ // don't render it
+ continue;
}
- Con_Printf("\n");
+ out->mesh.num_vertices = numvertices;
+ out->mesh.num_triangles = numtriangles;
+ if (meshvertices + out->mesh.num_vertices > 65536)
+ break;
+ meshvertices += out->mesh.num_vertices;
+ meshtriangles += out->mesh.num_triangles;
}
- // for shadow volumes
- Mod_BuildTriangleNeighbors(out->data_neighbor3i, out->data_element3i, out->num_triangles);
- // for per pixel lighting
- Mod_BuildTextureVectorsAndNormals(out->num_vertices, out->num_triangles, out->data_vertex3f, out->data_texcoordtexture2f, out->data_element3i, out->data_svector3f, out->data_tvector3f, out->data_normal3f);
- // calculate a bounding box
- VectorClear(out->mins);
- VectorClear(out->maxs);
- if (out->num_vertices)
+
+ i = oldi;
+ in = oldin;
+ out = oldout;
+ mesh = tempmeshlist[meshnum] = Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, 0, 0, false, false, true);
+ meshvertices = 0;
+ meshtriangles = 0;
+ for (;i < count && meshvertices + out->mesh.num_vertices <= mesh->num_vertices;i++, in++, out++)
{
- VectorCopy(out->data_vertex3f, out->mins);
- VectorCopy(out->data_vertex3f, out->maxs);
- for (j = 1, v = out->data_vertex3f + 3;j < out->num_vertices;j++, v += 3)
+ if (out->mesh.num_vertices < 3 || out->mesh.num_triangles < 1)
+ continue;
+
+ type = LittleLong(in->type);
+ firstvertex = LittleLong(in->firstvertex);
+ firstelement = LittleLong(in->firstelement);
+ out->mesh.data_vertex3f = mesh->data_vertex3f + meshvertices * 3;
+ out->mesh.data_svector3f = mesh->data_svector3f + meshvertices * 3;
+ out->mesh.data_tvector3f = mesh->data_tvector3f + meshvertices * 3;
+ out->mesh.data_normal3f = mesh->data_normal3f + meshvertices * 3;
+ out->mesh.data_texcoordtexture2f = mesh->data_texcoordtexture2f + meshvertices * 2;
+ out->mesh.data_texcoordlightmap2f = mesh->data_texcoordlightmap2f + meshvertices * 2;
+ out->mesh.data_lightmapcolor4f = mesh->data_lightmapcolor4f + meshvertices * 4;
+ out->mesh.data_element3i = mesh->data_element3i + meshtriangles * 3;
+ out->mesh.data_neighbor3i = mesh->data_neighbor3i + meshtriangles * 3;
+ switch(type)
{
- out->mins[0] = min(out->mins[0], v[0]);
- out->maxs[0] = max(out->maxs[0], v[0]);
- out->mins[1] = min(out->mins[1], v[1]);
- out->maxs[1] = max(out->maxs[1], v[1]);
- out->mins[2] = min(out->mins[2], v[2]);
- out->maxs[2] = max(out->maxs[2], v[2]);
+ case Q3FACETYPE_POLYGON:
+ case Q3FACETYPE_MESH:
+ // no processing necessary
+ for (j = 0;j < out->mesh.num_vertices;j++)
+ {
+ out->mesh.data_vertex3f[j * 3 + 0] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 0];
+ out->mesh.data_vertex3f[j * 3 + 1] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 1];
+ out->mesh.data_vertex3f[j * 3 + 2] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 2];
+ out->mesh.data_texcoordtexture2f[j * 2 + 0] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 0];
+ out->mesh.data_texcoordtexture2f[j * 2 + 1] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 1];
+ out->mesh.data_texcoordlightmap2f[j * 2 + 0] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 0];
+ out->mesh.data_texcoordlightmap2f[j * 2 + 1] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 1];
+ out->mesh.data_lightmapcolor4f[j * 4 + 0] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 0];
+ out->mesh.data_lightmapcolor4f[j * 4 + 1] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 1];
+ out->mesh.data_lightmapcolor4f[j * 4 + 2] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 2];
+ out->mesh.data_lightmapcolor4f[j * 4 + 3] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 3];
+ }
+ for (j = 0;j < out->mesh.num_triangles*3;j++)
+ out->mesh.data_element3i[j] = loadmodel->brushq3.data_element3i[firstelement + j];
+ break;
+ case Q3FACETYPE_PATCH:
+ patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
+ patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
+ originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
+ originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
+ originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
+ originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
+ // convert patch to Q3FACETYPE_MESH
+ xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
+ ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
+ // bound to user settings
+ xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
+ ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
+ // bound to sanity settings
+ xtess = bound(1, xtess, 1024);
+ ytess = bound(1, ytess, 1024);
+ // bound to user limit on vertices
+ while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
+ {
+ if (xtess > ytess)
+ xtess--;
+ else
+ ytess--;
+ }
+ finalwidth = ((patchsize[0] - 1) * xtess) + 1;
+ finalheight = ((patchsize[1] - 1) * ytess) + 1;
+ finalvertices = finalwidth * finalheight;
+ finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+ type = Q3FACETYPE_MESH;
+ // generate geometry
+ // (note: normals are skipped because they get recalculated)
+ Q3PatchTesselateFloat(3, sizeof(float[3]), out->mesh.data_vertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
+ Q3PatchTesselateFloat(2, sizeof(float[2]), out->mesh.data_texcoordtexture2f, patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordtexture2f, xtess, ytess);
+ Q3PatchTesselateFloat(2, sizeof(float[2]), out->mesh.data_texcoordlightmap2f, patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
+ Q3PatchTesselateFloat(4, sizeof(float[4]), out->mesh.data_lightmapcolor4f, patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
+ Q3PatchTriangleElements(out->mesh.data_element3i, finalwidth, finalheight);
+ out->mesh.num_triangles = Mod_RemoveDegenerateTriangles(out->mesh.num_triangles, out->mesh.data_element3i, out->mesh.data_element3i, out->mesh.data_vertex3f);
+ if (developer.integer >= 2)
+ {
+ if (out->mesh.num_triangles < finaltriangles)
+ Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->mesh.num_vertices, finaltriangles, finaltriangles - out->mesh.num_triangles, out->mesh.num_triangles);
+ else
+ Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->mesh.num_vertices, out->mesh.num_triangles);
+ }
+ // q3map does not put in collision brushes for curves... ugh
+ // build the lower quality collision geometry
+ xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
+ ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
+ // bound to user settings
+ xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
+ ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
+ // bound to sanity settings
+ xtess = bound(1, xtess, 1024);
+ ytess = bound(1, ytess, 1024);
+ // bound to user limit on vertices
+ while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
+ {
+ if (xtess > ytess)
+ xtess--;
+ else
+ ytess--;
+ }
+ finalwidth = ((patchsize[0] - 1) * xtess) + 1;
+ finalheight = ((patchsize[1] - 1) * ytess) + 1;
+ finalvertices = finalwidth * finalheight;
+ finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
+
+ out->mesh.data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
+ out->mesh.data_collisionelement3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
+ out->mesh.num_collisionvertices = finalvertices;
+ out->mesh.num_collisiontriangles = finaltriangles;
+ Q3PatchTesselateFloat(3, sizeof(float[3]), out->mesh.data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
+ Q3PatchTriangleElements(out->mesh.data_collisionelement3i, finalwidth, finalheight);
+
+ //Mod_SnapVertices(3, out->mesh.num_vertices, out->mesh.data_vertex3f, 0.25);
+ Mod_SnapVertices(3, out->mesh.num_collisionvertices, out->mesh.data_collisionvertex3f, 1);
+
+ oldnumtriangles = out->mesh.num_triangles;
+ oldnumtriangles2 = out->mesh.num_collisiontriangles;
+ out->mesh.num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->mesh.num_collisiontriangles, out->mesh.data_collisionelement3i, out->mesh.data_collisionelement3i, out->mesh.data_collisionvertex3f);
+ if (developer.integer)
+ Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->mesh.num_vertices, out->mesh.num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->mesh.num_triangles, oldnumtriangles2 - out->mesh.num_collisiontriangles);
+ break;
+ default:
+ break;
+ }
+ meshvertices += out->mesh.num_vertices;
+ meshtriangles += out->mesh.num_triangles;
+ for (j = 0, invalidelements = 0;j < out->mesh.num_triangles * 3;j++)
+ if (out->mesh.data_element3i[j] < 0 || out->mesh.data_element3i[j] >= out->mesh.num_vertices)
+ invalidelements++;
+ if (invalidelements)
+ {
+ Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, type, out->texture->name, out->texture->surfaceflags, firstvertex, out->mesh.num_vertices, firstelement, out->mesh.num_triangles * 3);
+ for (j = 0;j < out->mesh.num_triangles * 3;j++)
+ {
+ Con_Printf(" %i", out->mesh.data_element3i[j]);
+ if (out->mesh.data_element3i[j] < 0 || out->mesh.data_element3i[j] >= out->mesh.num_vertices)
+ out->mesh.data_element3i[j] = 0;
+ }
+ Con_Print("\n");
+ }
+ // for shadow volumes
+ Mod_BuildTriangleNeighbors(out->mesh.data_neighbor3i, out->mesh.data_element3i, out->mesh.num_triangles);
+ // for per pixel lighting
+ Mod_BuildTextureVectorsAndNormals(out->mesh.num_vertices, out->mesh.num_triangles, out->mesh.data_vertex3f, out->mesh.data_texcoordtexture2f, out->mesh.data_element3i, out->mesh.data_svector3f, out->mesh.data_tvector3f, out->mesh.data_normal3f);
+ // calculate a bounding box
+ VectorClear(out->mins);
+ VectorClear(out->maxs);
+ if (out->mesh.num_vertices)
+ {
+ VectorCopy(out->mesh.data_vertex3f, out->mins);
+ VectorCopy(out->mesh.data_vertex3f, out->maxs);
+ for (j = 1, v = out->mesh.data_vertex3f + 3;j < out->mesh.num_vertices;j++, v += 3)
+ {
+ out->mins[0] = min(out->mins[0], v[0]);
+ out->maxs[0] = max(out->maxs[0], v[0]);
+ out->mins[1] = min(out->mins[1], v[1]);
+ out->maxs[1] = max(out->maxs[1], v[1]);
+ out->mins[2] = min(out->mins[2], v[2]);
+ out->maxs[2] = max(out->maxs[2], v[2]);
+ }
+ out->mins[0] -= 1.0f;
+ out->mins[1] -= 1.0f;
+ out->mins[2] -= 1.0f;
+ out->maxs[0] += 1.0f;
+ out->maxs[1] += 1.0f;
+ out->maxs[2] += 1.0f;
}
- out->mins[0] -= 1.0f;
- out->mins[1] -= 1.0f;
- out->mins[2] -= 1.0f;
- out->maxs[0] += 1.0f;
- out->maxs[1] += 1.0f;
- out->maxs[2] += 1.0f;
+ // set lightmap styles for consistency with q1bsp
+ out->styles[0] = 0;
+ out->styles[1] = 255;
+ out->styles[2] = 255;
+ out->styles[3] = 255;
}
}
- // LordHavoc: experimental array merger (disabled because it wastes time and uses 2x memory while merging)
- /*
+ // now store the completed list of meshes
+ loadmodel->nummeshes = meshnum;
+ if (loadmodel->nummeshes)
{
- int totalverts, totaltris;
- int originalnum_vertices;
- float *originaldata_vertex3f;
- float *originaldata_texcoordtexture2f;
- float *originaldata_texcoordlightmap2f;
- float *originaldata_svector3f;
- float *originaldata_tvector3f;
- float *originaldata_normal3f;
- float *originaldata_color4f;
- int originalnum_triangles;
- int *originaldata_element3i;
- int *originaldata_neighbor3i;
-
- totalverts = 0;
- totaltris = 0;
- for (i = 0, out = loadmodel->brushq3.data_faces;i < count;i++, out++)
- {
- if (!out->type)
- continue;
- totalverts += out->num_vertices;
- totaltris += out->num_triangles;
- }
-
- originalnum_vertices = loadmodel->brushq3.num_vertices;
- originaldata_vertex3f = loadmodel->brushq3.data_vertex3f;
- originaldata_texcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f;
- originaldata_texcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f;
- originaldata_svector3f = loadmodel->brushq3.data_svector3f;
- originaldata_tvector3f = loadmodel->brushq3.data_tvector3f;
- originaldata_normal3f = loadmodel->brushq3.data_normal3f;
- originaldata_color4f = loadmodel->brushq3.data_color4f;
- originalnum_triangles = loadmodel->brushq3.num_triangles;
- originaldata_element3i = loadmodel->brushq3.data_element3i;
- originaldata_neighbor3i = loadmodel->brushq3.data_neighbor3i;
- loadmodel->brushq3.num_vertices = totalverts;
- loadmodel->brushq3.data_vertex3f = Mem_Alloc(loadmodel->mempool, totalverts * (sizeof(float) * (3 + 2 + 2 + 3 + 3 + 3 + 4)) + totaltris * (sizeof(int) * (3 * 2)));
- loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_vertex3f + totalverts * 3;
- loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + totalverts * 2;
- loadmodel->brushq3.data_svector3f = loadmodel->brushq3.data_texcoordlightmap2f + totalverts * 2;
- loadmodel->brushq3.data_tvector3f = loadmodel->brushq3.data_svector3f + totalverts * 3;
- loadmodel->brushq3.data_normal3f = loadmodel->brushq3.data_tvector3f + totalverts * 3;
- loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_normal3f + totalverts * 3;
- loadmodel->brushq3.num_triangles = totaltris;
- loadmodel->brushq3.data_element3i = (int *)(loadmodel->brushq3.data_color4f + totalverts * 4);
- loadmodel->brushq3.data_neighbor3i = loadmodel->brushq3.data_element3i + totaltris * 3;
- totalverts = 0;
- totaltris = 0;
- for (i = 0, out = loadmodel->brushq3.data_faces;i < count;i++, out++)
- {
- if (!out->type)
- continue;
- Con_Printf("totalverts %i, totaltris %i\n", totalverts, totaltris);
- memcpy(loadmodel->brushq3.data_vertex3f + totalverts * 3, out->data_vertex3f, out->num_vertices * 3 * sizeof(float));
- memcpy(loadmodel->brushq3.data_texcoordtexture2f + totalverts * 2, out->data_texcoordtexture2f, out->num_vertices * 2 * sizeof(float));
- memcpy(loadmodel->brushq3.data_texcoordlightmap2f + totalverts * 2, out->data_texcoordlightmap2f, out->num_vertices * 2 * sizeof(float));
- memcpy(loadmodel->brushq3.data_svector3f + totalverts * 3, out->data_svector3f, out->num_vertices * 3 * sizeof(float));
- memcpy(loadmodel->brushq3.data_tvector3f + totalverts * 3, out->data_tvector3f, out->num_vertices * 3 * sizeof(float));
- memcpy(loadmodel->brushq3.data_normal3f + totalverts * 3, out->data_normal3f, out->num_vertices * 3 * sizeof(float));
- memcpy(loadmodel->brushq3.data_color4f + totalverts * 4, out->data_color4f, out->num_vertices * 4 * sizeof(float));
- memcpy(loadmodel->brushq3.data_element3i + totaltris * 3, out->data_element3i, out->num_triangles * 3 * sizeof(int));
- memcpy(loadmodel->brushq3.data_neighbor3i + totaltris * 3, out->data_neighbor3i, out->num_triangles * 3 * sizeof(int));
- if (out->firstvertex == -1)
- Mem_Free(out->data_vertex3f);
- if (out->firstelement == -1)
- Mem_Free(out->data_element3i);
- out->firstvertex = totalverts;
- out->data_vertex3f = loadmodel->brushq3.data_vertex3f + out->firstvertex * 3;
- out->data_texcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + out->firstvertex * 2;
- out->data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + out->firstvertex * 2;
- out->data_svector3f = loadmodel->brushq3.data_svector3f + out->firstvertex * 3;
- out->data_tvector3f = loadmodel->brushq3.data_tvector3f + out->firstvertex * 3;
- out->data_normal3f = loadmodel->brushq3.data_normal3f + out->firstvertex * 3;
- out->data_color4f = loadmodel->brushq3.data_color4f + out->firstvertex * 4;
- out->firstelement = totaltris * 3;
- out->data_element3i = loadmodel->brushq3.data_element3i + out->firstelement;
- out->data_neighbor3i = loadmodel->brushq3.data_neighbor3i + out->firstelement;
- //for (j = 0;j < out->numtriangles * 3;j++)
- // out->data_element3i[j] += totalverts - out->firstvertex;
- totalverts += out->num_vertices;
- totaltris += out->num_triangles;
- }
- Mem_Free(originaldata_vertex3f);
- Mem_Free(originaldata_element3i);
+ loadmodel->meshlist = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t *) * loadmodel->nummeshes);
+ memcpy(loadmodel->meshlist, tempmeshlist, sizeof(surfmesh_t *) * loadmodel->nummeshes);
}
- */
+
+ // free the no longer needed vertex data
+ loadmodel->brushq3.num_vertices = 0;
+ Mem_Free(loadmodel->brushq3.data_vertex3f);
+ loadmodel->brushq3.data_vertex3f = NULL;
+ loadmodel->brushq3.data_texcoordtexture2f = NULL;
+ loadmodel->brushq3.data_texcoordlightmap2f = NULL;
+ loadmodel->brushq3.data_color4f = NULL;
+ // free the no longer needed triangle data
+ loadmodel->brushq3.num_triangles = 0;
+ Mem_Free(loadmodel->brushq3.data_element3i);
+ loadmodel->brushq3.data_element3i = NULL;
}
static void Mod_Q3BSP_LoadModels(lump_t *l)
{
q3dmodel_t *in;
- q3mmodel_t *out;
+ q3dmodel_t *out;
int i, j, n, c, count;
in = (void *)(mod_base + l->fileofs);
}
n = LittleLong(in->firstface);
c = LittleLong(in->numfaces);
- if (n < 0 || n + c > loadmodel->brushq3.num_faces)
- Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)\n", n, n + c, loadmodel->brushq3.num_faces);
- out->firstface = loadmodel->brushq3.data_faces + n;
+ if (n < 0 || n + c > loadmodel->brush.num_surfaces)
+ Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)\n", n, n + c, loadmodel->brush.num_surfaces);
+ out->firstface = n;
out->numfaces = c;
n = LittleLong(in->firstbrush);
c = LittleLong(in->numbrushes);
- if (n < 0 || n + c > loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)\n", n, n + c, loadmodel->brushq3.num_brushes);
- out->firstbrush = loadmodel->brushq3.data_brushes + n;
+ if (n < 0 || n + c > loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)\n", n, n + c, loadmodel->brush.num_brushes);
+ out->firstbrush = n;
out->numbrushes = c;
}
}
static void Mod_Q3BSP_LoadLeafBrushes(lump_t *l)
{
int *in;
- q3mbrush_t **out;
+ int *out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_leafbrushes = out;
- loadmodel->brushq3.num_leafbrushes = count;
+ loadmodel->brush.data_leafbrushes = out;
+ loadmodel->brush.num_leafbrushes = count;
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(*in);
- if (n < 0 || n >= loadmodel->brushq3.num_brushes)
- Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)\n", n, loadmodel->brushq3.num_brushes);
- *out = loadmodel->brushq3.data_brushes + n;
+ if (n < 0 || n >= loadmodel->brush.num_brushes)
+ Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)\n", n, loadmodel->brush.num_brushes);
+ *out = n;
}
}
static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
{
int *in;
- q3mface_t **out;
+ int *out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_leaffaces = out;
- loadmodel->brushq3.num_leaffaces = count;
+ loadmodel->brush.data_leafsurfaces = out;
+ loadmodel->brush.num_leafsurfaces = count;
for (i = 0;i < count;i++, in++, out++)
{
n = LittleLong(*in);
- if (n < 0 || n >= loadmodel->brushq3.num_faces)
- Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->brushq3.num_faces);
- *out = loadmodel->brushq3.data_faces + n;
+ if (n < 0 || n >= loadmodel->brush.num_surfaces)
+ Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)\n", n, loadmodel->brush.num_surfaces);
+ *out = n;
}
}
static void Mod_Q3BSP_LoadLeafs(lump_t *l)
{
q3dleaf_t *in;
- q3mleaf_t *out;
+ mleaf_t *out;
int i, j, n, c, count;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_leafs = out;
- loadmodel->brushq3.num_leafs = count;
+ loadmodel->brush.data_leafs = out;
+ loadmodel->brush.num_leafs = count;
for (i = 0;i < count;i++, in++, out++)
{
- out->isnode = false;
out->parent = NULL;
+ out->plane = NULL;
out->clusterindex = LittleLong(in->clusterindex);
out->areaindex = LittleLong(in->areaindex);
for (j = 0;j < 3;j++)
{
// yes the mins/maxs are ints
- out->mins[j] = LittleLong(in->mins[j]);
- out->maxs[j] = LittleLong(in->maxs[j]);
+ out->mins[j] = LittleLong(in->mins[j]) - 1;
+ out->maxs[j] = LittleLong(in->maxs[j]) + 1;
}
n = LittleLong(in->firstleafface);
c = LittleLong(in->numleaffaces);
- if (n < 0 || n + c > loadmodel->brushq3.num_leaffaces)
- Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafface range %i : %i (%i leaffaces)\n", n, n + c, loadmodel->brushq3.num_leaffaces);
- out->firstleafface = loadmodel->brushq3.data_leaffaces + n;
- out->numleaffaces = c;
+ if (n < 0 || n + c > loadmodel->brush.num_leafsurfaces)
+ Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafsurface range %i : %i (%i leafsurfaces)\n", n, n + c, loadmodel->brush.num_leafsurfaces);
+ out->firstleafsurface = loadmodel->brush.data_leafsurfaces + n;
+ out->numleafsurfaces = c;
n = LittleLong(in->firstleafbrush);
c = LittleLong(in->numleafbrushes);
- if (n < 0 || n + c > loadmodel->brushq3.num_leafbrushes)
- Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)\n", n, n + c, loadmodel->brushq3.num_leafbrushes);
- out->firstleafbrush = loadmodel->brushq3.data_leafbrushes + n;
+ if (n < 0 || n + c > loadmodel->brush.num_leafbrushes)
+ Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)\n", n, n + c, loadmodel->brush.num_leafbrushes);
+ out->firstleafbrush = loadmodel->brush.data_leafbrushes + n;
out->numleafbrushes = c;
}
}
-static void Mod_Q3BSP_LoadNodes_RecursiveSetParent(q3mnode_t *node, q3mnode_t *parent)
-{
- if (node->parent)
- Host_Error("Mod_Q3BSP_LoadNodes_RecursiveSetParent: runaway recursion\n");
- node->parent = parent;
- if (node->isnode)
- {
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
- }
-}
-
static void Mod_Q3BSP_LoadNodes(lump_t *l)
{
q3dnode_t *in;
- q3mnode_t *out;
+ mnode_t *out;
int i, j, n, count;
in = (void *)(mod_base + l->fileofs);
count = l->filelen / sizeof(*in);
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
- loadmodel->brushq3.data_nodes = out;
- loadmodel->brushq3.num_nodes = count;
+ loadmodel->brush.data_nodes = out;
+ loadmodel->brush.num_nodes = count;
for (i = 0;i < count;i++, in++, out++)
{
- out->isnode = true;
out->parent = NULL;
n = LittleLong(in->planeindex);
- if (n < 0 || n >= loadmodel->brushq3.num_planes)
- Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)\n", n, loadmodel->brushq3.num_planes);
- out->plane = loadmodel->brushq3.data_planes + n;
+ if (n < 0 || n >= loadmodel->brush.num_planes)
+ Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)\n", n, loadmodel->brush.num_planes);
+ out->plane = loadmodel->brush.data_planes + n;
for (j = 0;j < 2;j++)
{
n = LittleLong(in->childrenindex[j]);
if (n >= 0)
{
- if (n >= loadmodel->brushq3.num_nodes)
- Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)\n", n, loadmodel->brushq3.num_nodes);
- out->children[j] = loadmodel->brushq3.data_nodes + n;
+ if (n >= loadmodel->brush.num_nodes)
+ Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)\n", n, loadmodel->brush.num_nodes);
+ out->children[j] = loadmodel->brush.data_nodes + n;
}
else
{
n = -1 - n;
- if (n >= loadmodel->brushq3.num_leafs)
- Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)\n", n, loadmodel->brushq3.num_leafs);
- out->children[j] = (q3mnode_t *)(loadmodel->brushq3.data_leafs + n);
+ if (n >= loadmodel->brush.num_leafs)
+ Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)\n", n, loadmodel->brush.num_leafs);
+ out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + n);
}
}
for (j = 0;j < 3;j++)
{
// yes the mins/maxs are ints
- out->mins[j] = LittleLong(in->mins[j]);
- out->maxs[j] = LittleLong(in->maxs[j]);
+ out->mins[j] = LittleLong(in->mins[j]) - 1;
+ out->maxs[j] = LittleLong(in->maxs[j]) + 1;
}
}
// set the parent pointers
- Mod_Q3BSP_LoadNodes_RecursiveSetParent(loadmodel->brushq3.data_nodes, NULL);
+ Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);
}
static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
q3dlightgrid_t *out;
int count;
- if (l->filelen == 0)
- return;
-
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
Host_Error("Mod_Q3BSP_LoadLightGrid: funny lump size in %s",loadmodel->name);
loadmodel->brushq3.num_lightgrid_isize[1] = loadmodel->brushq3.num_lightgrid_imaxs[1] - loadmodel->brushq3.num_lightgrid_imins[1] + 1;
loadmodel->brushq3.num_lightgrid_isize[2] = loadmodel->brushq3.num_lightgrid_imaxs[2] - loadmodel->brushq3.num_lightgrid_imins[2] + 1;
count = loadmodel->brushq3.num_lightgrid_isize[0] * loadmodel->brushq3.num_lightgrid_isize[1] * loadmodel->brushq3.num_lightgrid_isize[2];
- if (l->filelen < count * (int)sizeof(*in))
- Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)\n", l->filelen, count * sizeof(*in), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]);
- if (l->filelen != count * (int)sizeof(*in))
- Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", count * sizeof(*in), l->filelen);
+ if (l->filelen)
+ {
+ if (l->filelen < count * (int)sizeof(*in))
+ Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)\n", l->filelen, count * sizeof(*in), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]);
+ if (l->filelen != count * (int)sizeof(*in))
+ Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", count * sizeof(*in), l->filelen);
+ }
out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
loadmodel->brushq3.data_lightgrid = out;
loadmodel->brushq3.num_lightgrid = count;
// no swapping or validation necessary
- memcpy(out, in, count * (int)sizeof(*out));
+ if (l->filelen)
+ memcpy(out, in, count * (int)sizeof(*out));
+ else
+ {
+ // no data, fill with white
+ int i;
+ for (i = 0;i < count;i++)
+ {
+ out[i].ambientrgb[0] = 128;
+ out[i].ambientrgb[1] = 128;
+ out[i].ambientrgb[2] = 128;
+ out[i].diffusergb[0] = 0;
+ out[i].diffusergb[1] = 0;
+ out[i].diffusergb[2] = 0;
+ out[i].diffusepitch = 0;
+ out[i].diffuseyaw = 0;
+ }
+ }
Matrix4x4_CreateScale3(&loadmodel->brushq3.num_lightgrid_indexfromworld, loadmodel->brushq3.num_lightgrid_scale[0], loadmodel->brushq3.num_lightgrid_scale[1], loadmodel->brushq3.num_lightgrid_scale[2]);
Matrix4x4_ConcatTranslate(&loadmodel->brushq3.num_lightgrid_indexfromworld, -loadmodel->brushq3.num_lightgrid_imins[0] * loadmodel->brushq3.num_lightgrid_cellsize[0], -loadmodel->brushq3.num_lightgrid_imins[1] * loadmodel->brushq3.num_lightgrid_cellsize[1], -loadmodel->brushq3.num_lightgrid_imins[2] * loadmodel->brushq3.num_lightgrid_cellsize[2]);
int totalchains;
if (l->filelen == 0)
+ {
+ int i;
+ // unvised maps often have cluster indices even without pvs, so check
+ // leafs to find real number of clusters
+ loadmodel->brush.num_pvsclusters = 1;
+ for (i = 0;i < loadmodel->brush.num_leafs;i++)
+ loadmodel->brush.num_pvsclusters = max(loadmodel->brush.num_pvsclusters, loadmodel->brush.data_leafs[i].clusterindex + 1);
+
+ // create clusters
+ loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
+ totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
+ loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
+ memset(loadmodel->brush.data_pvsclusters, 0xFF, totalchains);
return;
+ }
in = (void *)(mod_base + l->fileofs);
if (l->filelen < 9)
Host_Error("Mod_Q3BSP_LoadPVS: funny lump size in %s",loadmodel->name);
- loadmodel->brushq3.num_pvsclusters = LittleLong(in->numclusters);
- loadmodel->brushq3.num_pvschainlength = LittleLong(in->chainlength);
- if (loadmodel->brushq3.num_pvschainlength < ((loadmodel->brushq3.num_pvsclusters + 7) / 8))
- Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8\n", loadmodel->brushq3.num_pvschainlength, loadmodel->brushq3.num_pvsclusters);
- totalchains = loadmodel->brushq3.num_pvschainlength * loadmodel->brushq3.num_pvsclusters;
+ loadmodel->brush.num_pvsclusters = LittleLong(in->numclusters);
+ loadmodel->brush.num_pvsclusterbytes = LittleLong(in->chainlength);
+ if (loadmodel->brush.num_pvsclusterbytes < ((loadmodel->brush.num_pvsclusters + 7) / 8))
+ Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8\n", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters);
+ totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
if (l->filelen < totalchains + (int)sizeof(*in))
- Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)\n", loadmodel->brushq3.num_pvsclusters, loadmodel->brushq3.num_pvschainlength, totalchains + sizeof(*in), l->filelen);
+ Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)\n", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, totalchains + sizeof(*in), l->filelen);
- loadmodel->brushq3.data_pvschains = Mem_Alloc(loadmodel->mempool, totalchains);
- memcpy(loadmodel->brushq3.data_pvschains, (qbyte *)(in + 1), totalchains);
-}
-
-static void Mod_Q3BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, vec_t radius)
-{
- // FIXME: finish this code
- VectorCopy(in, out);
+ loadmodel->brush.data_pvsclusters = Mem_Alloc(loadmodel->mempool, totalchains);
+ memcpy(loadmodel->brush.data_pvsclusters, (qbyte *)(in + 1), totalchains);
}
static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
//Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]);
}
-static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, q3mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe)
+static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe)
+{
+ int i;
+ mleaf_t *leaf;
+ colbrushf_t *brush;
+ // find which leaf the point is in
+ while (node->plane)
+ node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
+ // point trace the brushes
+ leaf = (mleaf_t *)node;
+ for (i = 0;i < leaf->numleafbrushes;i++)
+ {
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
+ {
+ brush->markframe = markframe;
+ Collision_TracePointBrushFloat(trace, point, brush);
+ }
+ }
+ // can't do point traces on curves (they have no thickness)
+}
+
+static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
int i, startside, endside;
- float dist1, dist2, midfrac, mid[3], segmentmins[3], segmentmaxs[3];
- q3mleaf_t *leaf;
- q3mface_t *face;
+ float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
+ mleaf_t *leaf;
+ msurface_t *surface;
colbrushf_t *brush;
- if (startfrac >= trace->fraction)
+ if (startfrac > trace->realfraction)
return;
// note: all line fragments past first impact fraction are ignored
- while (node->isnode)
- {
- // recurse down node sides
- dist1 = PlaneDiff(start, node->plane);
- dist2 = PlaneDiff(end, node->plane);
- startside = dist1 < 0;
- endside = dist2 < 0;
- if (startside == endside)
- {
- // most of the time the line fragment is on one side of the plane
- node = node->children[startside];
- }
- else
+ if (VectorCompare(start, end))
+ {
+ // find which leaf the point is in
+ while (node->plane)
+ node = node->children[DotProduct(start, node->plane->normal) < node->plane->dist];
+ }
+ else
+ {
+ // find which nodes the line is in and recurse for them
+ while (node->plane)
{
- // line crosses node plane, split the line
- midfrac = dist1 / (dist1 - dist2);
- VectorLerp(linestart, midfrac, lineend, mid);
- // take the near side first
- Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe);
- if (midfrac < trace->fraction)
- Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe);
- return;
+ // recurse down node sides
+ dist1 = PlaneDiff(start, node->plane);
+ dist2 = PlaneDiff(end, node->plane);
+ startside = dist1 < 0;
+ endside = dist2 < 0;
+ if (startside == endside)
+ {
+ // most of the time the line fragment is on one side of the plane
+ node = node->children[startside];
+ }
+ else
+ {
+ // line crosses node plane, split the line
+ midfrac = dist1 / (dist1 - dist2);
+ VectorLerp(start, midfrac, end, mid);
+ // take the near side first
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+ if (midfrac <= trace->realfraction)
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+ return;
+ }
}
}
// hit a leaf
- segmentmins[0] = min(start[0], end[0]);
- segmentmins[1] = min(start[1], end[1]);
- segmentmins[2] = min(start[2], end[2]);
- segmentmaxs[0] = max(start[0], end[0]);
- segmentmaxs[1] = max(start[1], end[1]);
- segmentmaxs[2] = max(start[2], end[2]);
- leaf = (q3mleaf_t *)node;
+ nodesegmentmins[0] = min(start[0], end[0]);
+ nodesegmentmins[1] = min(start[1], end[1]);
+ nodesegmentmins[2] = min(start[2], end[2]);
+ nodesegmentmaxs[0] = max(start[0], end[0]);
+ nodesegmentmaxs[1] = max(start[1], end[1]);
+ nodesegmentmaxs[2] = max(start[2], end[2]);
+ // line trace the brushes
+ leaf = (mleaf_t *)node;
for (i = 0;i < leaf->numleafbrushes;i++)
{
- if (startfrac >= trace->fraction)
- return;
- brush = leaf->firstleafbrush[i]->colbrushf;
- if (brush && brush->markframe != markframe)
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
{
brush->markframe = markframe;
- if (BoxesOverlap(segmentmins, segmentmaxs, brush->mins, brush->maxs))
- Collision_TraceLineBrushFloat(trace, linestart, lineend, leaf->firstleafbrush[i]->colbrushf, leaf->firstleafbrush[i]->colbrushf);
+ Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
+ if (startfrac > trace->realfraction)
+ return;
}
}
- if (mod_q3bsp_curves_collisions.integer)
+ // can't do point traces on curves (they have no thickness)
+ if (mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end))
{
- for (i = 0;i < leaf->numleaffaces;i++)
+ // line trace the curves
+ for (i = 0;i < leaf->numleafsurfaces;i++)
{
- if (startfrac >= trace->fraction)
- return;
- face = leaf->firstleafface[i];
- if (face->collisions && face->collisionmarkframe != markframe)
+ surface = model->brush.data_surfaces + leaf->firstleafsurface[i];
+ if (surface->mesh.num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
{
- face->collisionmarkframe = markframe;
- if (BoxesOverlap(segmentmins, segmentmaxs, face->mins, face->maxs))
- Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+ surface->collisionmarkframe = markframe;
+ Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
+ if (startfrac > trace->realfraction)
+ return;
}
}
}
}
-static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, q3mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
+static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
{
- int i, sides;
+ int i;
+ //int sides;
float nodesegmentmins[3], nodesegmentmaxs[3];
- q3mleaf_t *leaf;
+ mleaf_t *leaf;
colbrushf_t *brush;
- q3mface_t *face;
- nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
- nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
- nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
- nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
- nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
- nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
- if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
- return;
- if (node->isnode)
- {
- // recurse down node sides
- sides = BoxOnPlaneSide(segmentmins, segmentmaxs, node->plane);
- if (sides == 3)
+ msurface_t *surface;
+ /*
+ // find which nodes the line is in and recurse for them
+ while (node->plane)
{
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, nodesegmentmins, nodesegmentmaxs);
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[1], thisbrush_start, thisbrush_end, markframe, nodesegmentmins, nodesegmentmaxs);
+ // recurse down node sides
+ int startside, endside;
+ float dist1near, dist1far, dist2near, dist2far;
+ BoxPlaneCornerDistances(thisbrush_start->mins, thisbrush_start->maxs, node->plane, &dist1near, &dist1far);
+ BoxPlaneCornerDistances(thisbrush_end->mins, thisbrush_end->maxs, node->plane, &dist2near, &dist2far);
+ startside = dist1near < 0;
+ startside = dist1near < 0 ? (dist1far < 0 ? 1 : 2) : (dist1far < 0 ? 2 : 0);
+ endside = dist2near < 0 ? (dist2far < 0 ? 1 : 2) : (dist2far < 0 ? 2 : 0);
+ if (startside == 2 || endside == 2)
+ {
+ // brushes cross plane
+ // do not clip anything, just take both sides
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ continue;
+ }
+ if (startside == 0)
+ {
+ if (endside == 0)
+ {
+ node = node->children[0];
+ continue;
+ }
+ else
+ {
+ //midf0 = dist1near / (dist1near - dist2near);
+ //midf1 = dist1far / (dist1far - dist2far);
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ continue;
+ }
+ }
+ else
+ {
+ if (endside == 0)
+ {
+ //midf0 = dist1near / (dist1near - dist2near);
+ //midf1 = dist1far / (dist1far - dist2far);
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ continue;
+ }
+ else
+ {
+ node = node->children[1];
+ continue;
+ }
+ }
+
+ if (dist1near < 0 && dist2near < 0 && dist1far < 0 && dist2far < 0){node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near < 0 && dist1far < 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near < 0 && dist1far >= 0 && dist2far < 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near < 0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near >= 0 && dist1far < 0 && dist2far < 0){node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near >= 0 && dist1far < 0 && dist2far >= 0){}
+ if (dist1near < 0 && dist2near >= 0 && dist1far >= 0 && dist2far < 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near < 0 && dist2near >= 0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near >= 0 && dist2near < 0 && dist1far < 0 && dist2far < 0){node = node->children[1];continue;}
+ if (dist1near >= 0 && dist2near < 0 && dist1far < 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near >= 0 && dist2near < 0 && dist1far >= 0 && dist2far < 0){}
+ if (dist1near >= 0 && dist2near < 0 && dist1far >= 0 && dist2far >= 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near >= 0 && dist2near >= 0 && dist1far < 0 && dist2far < 0){Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);node = node->children[1];continue;}
+ if (dist1near >= 0 && dist2near >= 0 && dist1far < 0 && dist2far >= 0){node = node->children[0];continue;}
+ if (dist1near >= 0 && dist2near >= 0 && dist1far >= 0 && dist2far < 0){node = node->children[0];continue;}
+ if (dist1near >= 0 && dist2near >= 0 && dist1far >= 0 && dist2far >= 0){node = node->children[0];continue;}
+ {
+ if (dist2near < 0) // d1n<0 && d2n<0
+ {
+ if (dist2near < 0) // d1n<0 && d2n<0
+ {
+ if (dist2near < 0) // d1n<0 && d2n<0
+ {
+ }
+ else // d1n<0 && d2n>0
+ {
+ }
+ }
+ else // d1n<0 && d2n>0
+ {
+ if (dist2near < 0) // d1n<0 && d2n<0
+ {
+ }
+ else // d1n<0 && d2n>0
+ {
+ }
+ }
+ }
+ else // d1n<0 && d2n>0
+ {
+ }
+ }
+ else // d1n>0
+ {
+ if (dist2near < 0) // d1n>0 && d2n<0
+ {
+ }
+ else // d1n>0 && d2n>0
+ {
+ }
+ }
+ if (dist1near < 0 == dist1far < 0 == dist2near < 0 == dist2far < 0)
+ {
+ node = node->children[startside];
+ continue;
+ }
+ if (dist1near < dist2near)
+ {
+ // out
+ if (dist1near >= 0)
+ {
+ node = node->children[0];
+ continue;
+ }
+ if (dist2far < 0)
+ {
+ node = node->children[1];
+ continue;
+ }
+ // dist1near < 0 && dist2far >= 0
+ }
+ else
+ {
+ // in
+ }
+ startside = dist1near < 0 ? (dist1far < 0 ? 1 : 2) : (dist1far < 0 ? 2 : 0);
+ endside = dist2near < 0 ? (dist2far < 0 ? 1 : 2) : (dist2far < 0 ? 2 : 0);
+ if (startside == 2 || endside == 2)
+ {
+ // brushes cross plane
+ // do not clip anything, just take both sides
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ }
+ else if (startside == endside)
+ node = node->children[startside];
+ else if (startside == 0) // endside = 1 (start infront, end behind)
+ {
+ }
+ else // startside == 1 endside = 0 (start behind, end infront)
+ {
+ }
+ == endside)
+ {
+ if (startside < 2)
+ node = node->children[startside];
+ else
+ {
+ // start and end brush cross plane
+ }
+ }
+ else
+ {
+ }
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ node = node->children[1];
+ else if (dist1near < 0 && dist1far < 0 && dist2near >= 0 && dist2far >= 0)
+ else if (dist1near >= 0 && dist1far >= 0 && dist2near < 0 && dist2far < 0)
+ else if (dist1near >= 0 && dist1far >= 0 && dist2near >= 0 && dist2far >= 0)
+ node = node->children[0];
+ else
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ {
+ }
+ else if (dist1near >= 0 && dist1far >= 0)
+ {
+ }
+ else // mixed (lying on plane)
+ {
+ }
+ {
+ if (dist2near < 0 && dist2far < 0)
+ {
+ }
+ else
+ node = node->children[1];
+ }
+ if (dist1near < 0 && dist1far < 0 && dist2near < 0 && dist2far < 0)
+ node = node->children[0];
+ else if (dist1near >= 0 && dist1far >= 0 && dist2near >= 0 && dist2far >= 0)
+ node = node->children[1];
+ else
+ {
+ // both sides
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ }
+ sides = dist1near || dist1near < 0 | dist1far < 0 | dist2near < 0 | dist
+ startside = dist1 < 0;
+ endside = dist2 < 0;
+ if (startside == endside)
+ {
+ // most of the time the line fragment is on one side of the plane
+ node = node->children[startside];
+ }
+ else
+ {
+ // line crosses node plane, split the line
+ midfrac = dist1 / (dist1 - dist2);
+ VectorLerp(start, midfrac, end, mid);
+ // take the near side first
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+ if (midfrac <= trace->fraction)
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
+ return;
+ }
}
- else if (sides == 2)
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[1], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
- else // sides == 1
+ */
+#if 1
+ for (;;)
+ {
+ nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
+ nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
+ nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
+ nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
+ nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
+ nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
+ if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
+ return;
+ if (!node->plane)
+ break;
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ }
+#elif 0
+ // FIXME: could be made faster by copying TraceLine code and making it use
+ // box plane distances... (variant on the BoxOnPlaneSide code)
+ for (;;)
+ {
+ nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
+ nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
+ nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
+ nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
+ nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
+ nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
+ if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
+ return;
+ if (!node->plane)
+ break;
+ if (mod_q3bsp_debugtracebrush.integer == 2)
+ {
Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
- /*
- dist = node->plane->dist - (1.0f / 8.0f);
- for (i = 0, ps = thisbrush_start->points, pe = thisbrush_end->points;i < thisbrush_start->numpoints;i++, ps++, pe++)
+ node = node->children[1];
+ continue;
+ }
+ else if (mod_q3bsp_debugtracebrush.integer == 1)
{
- if (DotProduct(ps->v, node->plane->normal) >= dist || DotProduct(pe->v, node->plane->normal) >= dist)
+ // recurse down node sides
+ sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
+ if (sides == 3)
{
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, nodesegmentmins, nodesegmentmaxs);
- break;
+ // segment box crosses plane
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ continue;
}
+ // take whichever side the segment box is on
+ node = node->children[sides - 1];
+ continue;
}
- */
- /*
- dist = node->plane->dist + (1.0f / 8.0f);
- for (i = 0, ps = thisbrush_start->points, pe = thisbrush_end->points;i < thisbrush_start->numpoints;i++, ps++, pe++)
+ else
{
- if (DotProduct(ps->v, node->plane->normal) <= dist || DotProduct(pe->v, node->plane->normal) <= dist)
+ // recurse down node sides
+ sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
+ if (sides == 3)
{
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[1], thisbrush_start, thisbrush_end, markframe, nodesegmentmins, nodesegmentmaxs);
- break;
+ // segment box crosses plane
+ // now check start and end brush boxes to handle a lot of 'diagonal' cases more efficiently...
+ sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, node->plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, node->plane);
+ if (sides == 3)
+ {
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ continue;
+ }
}
+ // take whichever side the segment box is on
+ node = node->children[sides - 1];
+ continue;
}
- */
- /*
- sides = BoxOnPlaneSide(boxstartmins, boxstartmaxs, node->plane) | BoxOnPlaneSide(boxendmins, boxendmaxs, node->plane);
- if (sides & 1)
- Mod_Q3BSP_TraceBox_RecursiveBSPNode(trace, node->children[0], boxstartmins, boxstartmaxs, boxendmins, boxendmaxs);
- if (sides & 2)
- Mod_Q3BSP_TraceBox_RecursiveBSPNode(trace, node->children[1], boxstartmins, boxstartmaxs, boxendmins, boxendmaxs);
- */
+ return;
}
- else
- {
- // hit a leaf
- leaf = (q3mleaf_t *)node;
- for (i = 0;i < leaf->numleafbrushes;i++)
+#else
+ // FIXME: could be made faster by copying TraceLine code and making it use
+ // box plane distances... (variant on the BoxOnPlaneSide code)
+ for (;;)
+ {
+ nodesegmentmins[0] = max(segmentmins[0], node->mins[0]);
+ nodesegmentmins[1] = max(segmentmins[1], node->mins[1]);
+ nodesegmentmins[2] = max(segmentmins[2], node->mins[2]);
+ nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0]);
+ nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1]);
+ nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2]);
+ if (nodesegmentmins[0] > nodesegmentmaxs[0] || nodesegmentmins[1] > nodesegmentmaxs[1] || nodesegmentmins[2] > nodesegmentmaxs[2])
+ return;
+ if (!node->plane)
+ break;
+ if (mod_q3bsp_debugtracebrush.integer == 2)
+ {
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ }
+ else if (mod_q3bsp_debugtracebrush.integer == 1)
+ {
+ // recurse down node sides
+ sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
+ if (sides == 3)
+ {
+ // segment box crosses plane
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ node = node->children[1];
+ }
+ else
+ {
+ // take whichever side the segment box is on
+ node = node->children[sides - 1];
+ }
+ }
+ else
{
- brush = leaf->firstleafbrush[i]->colbrushf;
- if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
+ // recurse down node sides
+ sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, node->plane);
+ if (sides == 3)
{
- brush->markframe = markframe;
- Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, leaf->firstleafbrush[i]->colbrushf, leaf->firstleafbrush[i]->colbrushf);
+ // segment box crosses plane
+ // now check start and end brush boxes to handle a lot of 'diagonal' cases more efficiently...
+ sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, node->plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, node->plane);
+ if (sides == 3)
+ {
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
+ sides = 2;
+ }
}
+ // take whichever side the segment box is on
+ node = node->children[sides - 1];
+ }
+ }
+#endif
+ // hit a leaf
+ leaf = (mleaf_t *)node;
+ for (i = 0;i < leaf->numleafbrushes;i++)
+ {
+ brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
+ if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
+ {
+ brush->markframe = markframe;
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush);
}
- if (mod_q3bsp_curves_collisions.integer)
+ }
+ if (mod_q3bsp_curves_collisions.integer)
+ {
+ for (i = 0;i < leaf->numleafsurfaces;i++)
{
- for (i = 0;i < leaf->numleaffaces;i++)
+ surface = model->brush.data_surfaces + leaf->firstleafsurface[i];
+ if (surface->mesh.num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
{
- face = leaf->firstleafface[i];
- // note: this can not be optimized with a face->collisionmarkframe because each triangle of the face would need to be marked as done individually (because each one is bbox culled individually), and if all are marked, then the face could be marked as done
- if (face->collisions && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, face->mins, face->maxs))
- Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
+ surface->collisionmarkframe = markframe;
+ Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
}
}
}
colbrushf_t *thisbrush_start, *thisbrush_end;
matrix4x4_t startmatrix, endmatrix;
static int markframe = 0;
- q3mface_t *face;
+ msurface_t *surface;
+ q3mbrush_t *brush;
memset(trace, 0, sizeof(*trace));
trace->fraction = 1;
+ trace->realfraction = 1;
trace->hitsupercontentsmask = hitsupercontentsmask;
Matrix4x4_CreateIdentity(&startmatrix);
Matrix4x4_CreateIdentity(&endmatrix);
segmentmaxs[2] = max(boxstartmaxs[2], boxendmaxs[2]);
if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxstartmins, boxstartmaxs) && VectorCompare(boxendmins, boxendmaxs))
{
- // line trace
- if (model->brushq3.submodel)
+ if (VectorCompare(boxstartmins, boxendmins))
{
- for (i = 0;i < model->brushq3.data_thismodel->numbrushes;i++)
- if (model->brushq3.data_thismodel->firstbrush[i].colbrushf)
- Collision_TraceLineBrushFloat(trace, boxstartmins, boxendmins, model->brushq3.data_thismodel->firstbrush[i].colbrushf, model->brushq3.data_thismodel->firstbrush[i].colbrushf);
- if (mod_q3bsp_curves_collisions.integer)
+ // point trace
+ if (model->brush.submodel)
{
- for (i = 0;i < model->brushq3.data_thismodel->numfaces;i++)
- {
- face = model->brushq3.data_thismodel->firstface + i;
- if (face->collisions)
- Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
- }
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TracePointBrushFloat(trace, boxstartmins, brush->colbrushf);
}
+ else
+ Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, ++markframe);
}
else
- Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model->brushq3.data_nodes, boxstartmins, boxendmins, 0, 1, boxstartmins, boxendmins, ++markframe);
+ {
+ // line trace
+ if (model->brush.submodel)
+ {
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TraceLineBrushFloat(trace, boxstartmins, boxendmins, brush->colbrushf, brush->colbrushf);
+ if (mod_q3bsp_curves_collisions.integer)
+ for (i = 0, surface = model->brush.data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
+ if (surface->mesh.num_collisiontriangles)
+ Collision_TraceLineTriangleMeshFloat(trace, boxstartmins, boxendmins, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
+ }
+ else
+ Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, boxstartmins, boxendmins, 0, 1, boxstartmins, boxendmins, ++markframe, segmentmins, segmentmaxs);
+ }
}
else
{
// box trace, performed as brush trace
thisbrush_start = Collision_BrushForBox(&startmatrix, boxstartmins, boxstartmaxs);
thisbrush_end = Collision_BrushForBox(&endmatrix, boxendmins, boxendmaxs);
- if (model->brushq3.submodel)
+ if (model->brush.submodel)
{
- for (i = 0;i < model->brushq3.data_thismodel->numbrushes;i++)
- if (model->brushq3.data_thismodel->firstbrush[i].colbrushf)
- Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, model->brushq3.data_thismodel->firstbrush[i].colbrushf, model->brushq3.data_thismodel->firstbrush[i].colbrushf);
+ for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
+ if (brush->colbrushf)
+ Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf);
if (mod_q3bsp_curves_collisions.integer)
- {
- for (i = 0;i < model->brushq3.data_thismodel->numfaces;i++)
- {
- face = model->brushq3.data_thismodel->firstface + i;
- if (face->collisions)
- Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, face->num_triangles, face->data_element3i, face->data_vertex3f, face->texture->supercontents, segmentmins, segmentmaxs);
- }
- }
+ for (i = 0, surface = model->brush.data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
+ if (surface->mesh.num_collisiontriangles)
+ Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->mesh.num_collisiontriangles, surface->mesh.data_collisionelement3i, surface->mesh.data_collisionvertex3f, surface->texture->supercontents, segmentmins, segmentmaxs);
}
else
- Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model->brushq3.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
+ Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
}
}
-
-static int Mod_Q3BSP_BoxTouchingPVS_RecursiveBSPNode(const model_t *model, const q3mnode_t *node, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
-{
- int clusterindex;
-loc0:
- if (!node->isnode)
- {
- // leaf
- clusterindex = ((q3mleaf_t *)node)->clusterindex;
- return pvs[clusterindex >> 3] & (1 << (clusterindex & 7));
- }
-
- // node - recurse down the BSP tree
- switch (BoxOnPlaneSide(mins, maxs, node->plane))
- {
- case 1: // front
- node = node->children[0];
- goto loc0;
- case 2: // back
- node = node->children[1];
- goto loc0;
- default: // crossing
- if (Mod_Q3BSP_BoxTouchingPVS_RecursiveBSPNode(model, node->children[0], pvs, mins, maxs))
- return true;
- node = node->children[1];
- goto loc0;
- }
- // never reached
- return false;
-}
-
-static int Mod_Q3BSP_BoxTouchingPVS(model_t *model, const qbyte *pvs, const vec3_t mins, const vec3_t maxs)
-{
- return Mod_Q3BSP_BoxTouchingPVS_RecursiveBSPNode(model, model->brushq3.data_nodes, pvs, mins, maxs);
-}
-
-//Returns PVS data for a given point
-//(note: can return NULL)
-static qbyte *Mod_Q3BSP_GetPVS(model_t *model, const vec3_t p)
-{
- q3mnode_t *node;
- Mod_CheckLoaded(model);
- node = model->brushq3.data_nodes;
- while (node->isnode)
- node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
- if (((q3mleaf_t *)node)->clusterindex >= 0)
- return model->brushq3.data_pvschains + ((q3mleaf_t *)node)->clusterindex * model->brushq3.num_pvschainlength;
- else
- return NULL;
-}
-
-static void Mod_Q3BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbytes, q3mnode_t *node)
-{
- int i;
- float d;
- qbyte *pvs;
-
- while (node->isnode)
- {
- d = PlaneDiff(org, node->plane);
- if (d > radius)
- node = node->children[0];
- else if (d < -radius)
- node = node->children[1];
- else
- {
- // go down both sides
- Mod_Q3BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, pvsbytes, node->children[0]);
- node = node->children[1];
- }
- }
- // if this is a leaf with a pvs, accumulate the pvs bits
- if (((q3mleaf_t *)node)->clusterindex >= 0)
- {
- pvs = model->brushq3.data_pvschains + ((q3mleaf_t *)node)->clusterindex * model->brushq3.num_pvschainlength;
- for (i = 0;i < pvsbytes;i++)
- pvsbuffer[i] |= pvs[i];
- }
- return;
-}
-
-//Calculates a PVS that is the inclusive or of all leafs within radius pixels
-//of the given point.
-static int Mod_Q3BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, qbyte *pvsbuffer, int pvsbufferlength)
-{
- int bytes = model->brushq3.num_pvschainlength;
- bytes = min(bytes, pvsbufferlength);
- memset(pvsbuffer, 0, bytes);
- Mod_Q3BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brushq3.data_nodes);
- return bytes;
-}
-
-
static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
{
int supercontents = 0;
- if (nativecontents & Q2CONTENTS_SOLID)
+ if (nativecontents & CONTENTSQ3_SOLID)
supercontents |= SUPERCONTENTS_SOLID;
- if (nativecontents & Q2CONTENTS_WATER)
+ if (nativecontents & CONTENTSQ3_WATER)
supercontents |= SUPERCONTENTS_WATER;
- if (nativecontents & Q2CONTENTS_SLIME)
+ if (nativecontents & CONTENTSQ3_SLIME)
supercontents |= SUPERCONTENTS_SLIME;
- if (nativecontents & Q2CONTENTS_LAVA)
+ if (nativecontents & CONTENTSQ3_LAVA)
supercontents |= SUPERCONTENTS_LAVA;
+ if (nativecontents & CONTENTSQ3_BODY)
+ supercontents |= SUPERCONTENTS_BODY;
+ if (nativecontents & CONTENTSQ3_CORPSE)
+ supercontents |= SUPERCONTENTS_CORPSE;
+ if (nativecontents & CONTENTSQ3_NODROP)
+ supercontents |= SUPERCONTENTS_NODROP;
return supercontents;
}
{
int nativecontents = 0;
if (supercontents & SUPERCONTENTS_SOLID)
- nativecontents |= Q2CONTENTS_SOLID;
+ nativecontents |= CONTENTSQ3_SOLID;
if (supercontents & SUPERCONTENTS_WATER)
- nativecontents |= Q2CONTENTS_WATER;
+ nativecontents |= CONTENTSQ3_WATER;
if (supercontents & SUPERCONTENTS_SLIME)
- nativecontents |= Q2CONTENTS_SLIME;
+ nativecontents |= CONTENTSQ3_SLIME;
if (supercontents & SUPERCONTENTS_LAVA)
- nativecontents |= Q2CONTENTS_LAVA;
+ nativecontents |= CONTENTSQ3_LAVA;
+ if (supercontents & SUPERCONTENTS_BODY)
+ nativecontents |= CONTENTSQ3_BODY;
+ if (supercontents & SUPERCONTENTS_CORPSE)
+ nativecontents |= CONTENTSQ3_CORPSE;
+ if (supercontents & SUPERCONTENTS_NODROP)
+ nativecontents |= CONTENTSQ3_NODROP;
return nativecontents;
}
-extern void R_Q3BSP_DrawSky(struct entity_render_s *ent);
-extern void R_Q3BSP_Draw(struct entity_render_s *ent);
-extern void R_Q3BSP_DrawShadowVolume(struct entity_render_s *ent, vec3_t relativelightorigin, float lightradius);
-extern void R_Q3BSP_DrawLight(struct entity_render_s *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
+void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
+{
+ int numleafs;
+ while (node->plane)
+ {
+ Mod_Q3BSP_RecursiveFindNumLeafs(node->children[0]);
+ node = node->children[1];
+ }
+ numleafs = ((mleaf_t *)node - loadmodel->brush.data_leafs) + 1;
+ if (loadmodel->brush.num_leafs < numleafs)
+ loadmodel->brush.num_leafs = numleafs;
+}
+
void Mod_Q3BSP_Load(model_t *mod, void *buffer)
{
- int i, j;
+ int i, j, numshadowmeshtriangles;
q3dheader_t *header;
float corner[3], yawradius, modelradius;
+ msurface_t *surface;
mod->type = mod_brushq3;
- mod->numframes = 1;
+ mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
mod->numskins = 1;
header = (q3dheader_t *)buffer;
i = LittleLong(header->version);
if (i != Q3BSPVERSION)
Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
- if (loadmodel->isworldmodel)
- {
+ if (mod->isworldmodel)
Cvar_SetValue("halflifebsp", false);
- // until we get a texture for it...
- R_ResetQuakeSky();
- }
mod->soundfromcenter = true;
mod->TraceBox = Mod_Q3BSP_TraceBox;
mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
- mod->brush.GetPVS = Mod_Q3BSP_GetPVS;
- mod->brush.FatPVS = Mod_Q3BSP_FatPVS;
- mod->brush.BoxTouchingPVS = Mod_Q3BSP_BoxTouchingPVS;
+ mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
+ mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
+ mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
+ mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
- mod->brush.FindNonSolidLocation = Mod_Q3BSP_FindNonSolidLocation;
- //mod->DrawSky = R_Q3BSP_DrawSky;
- mod->Draw = R_Q3BSP_Draw;
- mod->DrawShadowVolume = R_Q3BSP_DrawShadowVolume;
- mod->DrawLight = R_Q3BSP_DrawLight;
+ mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
+ mod->Draw = R_Q1BSP_Draw;
+ mod->GetLightInfo = R_Q1BSP_GetLightInfo;
+ mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ mod->DrawLight = R_Q1BSP_DrawLight;
mod_base = (qbyte *)header;
// swap all the lumps
- for (i = 0;i < (int) sizeof(*header) / 4;i++)
- ((int *)header)[i] = LittleLong(((int *)header)[i]);
+ header->ident = LittleLong(header->ident);
+ header->version = LittleLong(header->version);
+ for (i = 0;i < Q3HEADER_LUMPS;i++)
+ {
+ header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
+ header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
+ }
Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
Mod_Q3BSP_LoadPVS(&header->lumps[Q3LUMP_PVS]);
loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models;
- for (i = 0;i < loadmodel->brushq3.num_models;i++)
+ // make a single combined shadow mesh to allow optimized shadow volume creation
+ numshadowmeshtriangles = 0;
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
{
- if (i == 0)
- mod = loadmodel;
- else
+ surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
+ numshadowmeshtriangles += surface->mesh.num_triangles;
+ }
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
+ for (j = 0, surface = loadmodel->brush.data_surfaces;j < loadmodel->brush.num_surfaces;j++, surface++)
+ Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, surface->mesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->mesh.num_triangles, surface->mesh.data_element3i);
+ loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
+ Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
+
+ loadmodel->brush.num_leafs = 0;
+ Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
+
+ mod = loadmodel;
+ for (i = 0;i < loadmodel->brush.numsubmodels;i++)
+ {
+ if (i > 0)
{
char name[10];
// LordHavoc: only register submodels if it is the world
- // (prevents bsp models from replacing world submodels)
+ // (prevents external bsp models from replacing world submodels with
+ // their own)
if (!loadmodel->isworldmodel)
continue;
// duplicate the basic information
// textures and memory belong to the main model
mod->texturepool = NULL;
mod->mempool = NULL;
+ mod->brush.GetPVS = NULL;
+ mod->brush.FatPVS = NULL;
+ mod->brush.BoxTouchingPVS = NULL;
+ mod->brush.BoxTouchingVisibleLeafs = NULL;
+ mod->brush.LightPoint = NULL;
+ mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
}
- mod->brushq3.data_thismodel = loadmodel->brushq3.data_models + i;
- mod->brushq3.submodel = i;
-
- VectorCopy(mod->brushq3.data_thismodel->mins, mod->normalmins);
- VectorCopy(mod->brushq3.data_thismodel->maxs, mod->normalmaxs);
+ mod->brush.submodel = i;
+
+ // make the model surface list (used by shadowing/lighting)
+ mod->firstmodelsurface = mod->brushq3.data_models[i].firstface;
+ mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
+ mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
+ mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
+ mod->surfacelist = Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ mod->surfacelist[j] = mod->firstmodelsurface + j;
+
+ VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
+ VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
mod->radius = modelradius;
mod->radius2 = modelradius * modelradius;
- for (j = 0;j < mod->brushq3.data_thismodel->numfaces;j++)
- if (mod->brushq3.data_thismodel->firstface[j].texture->surfaceflags & Q3SURFACEFLAG_SKY)
+ for (j = 0;j < mod->nummodelsurfaces;j++)
+ if (mod->brush.data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY)
break;
- if (j < mod->brushq3.data_thismodel->numfaces)
- mod->DrawSky = R_Q3BSP_DrawSky;
+ if (j < mod->nummodelsurfaces)
+ mod->DrawSky = R_Q1BSP_DrawSky;
}
}
projects / xonotic / darkplaces.git / blobdiff