#include "quakedef.h"
#include "image.h"
#include "r_shadow.h"
-#include "winding.h"
+#include "polygon.h"
#include "curves.h"
// note: model_shared.c sets up r_notexture, and r_surf_notexture
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);
else
{
// box crosses plane, take one path and remember the other
- nodestack[nodestackindex++] = node->children[0];
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
node = node->children[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, true, 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, true, tx->name[0] != '*' && r_fullbrights.integer, mtdata, tx->width, tx->height);
}
}
if (tx->skin.base == NULL)
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)
{
}
}
+#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];
- winding_t *winding;
+ int numpoints;
+ double points[3*MAX_PORTALPOINTS];
struct portal_s *chain; // all portals are linked into a list
}
portal_t;
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.data_leafs;
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];
}
}
}
{
// 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]
+ if (p->numpoints >= 3 && 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)
{
numportals += 2;
- numpoints += p->winding->numpoints * 2;
+ numpoints += p->numpoints * 2;
}
p = p->chain;
}
{
pnext = p->chain;
- if (p->winding)
+ if (p->numpoints >= 3)
{
// 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
{
// first make the back to front portal(forward portal)
portal->points = point;
- portal->numpoints = p->winding->numpoints;
+ portal->numpoints = p->numpoints;
portal->plane.dist = p->plane.dist;
VectorCopy(p->plane.normal, portal->plane.normal);
portal->here = (mleaf_t *)p->nodes[1];
// copy points
for (j = 0;j < portal->numpoints;j++)
{
- VectorCopy(p->winding->points[j], point->position);
+ VectorCopy(p->points + j*3, point->position);
point++;
}
PlaneClassify(&portal->plane);
// then make the front to back portal(backward portal)
portal->points = point;
- portal->numpoints = p->winding->numpoints;
+ portal->numpoints = p->numpoints;
portal->plane.dist = -p->plane.dist;
VectorNegate(p->plane.normal, portal->plane.normal);
portal->here = (mleaf_t *)p->nodes[0];
// copy points
for (j = portal->numpoints - 1;j >= 0;j--)
{
- VectorCopy(p->winding->points[j], point->position);
+ VectorCopy(p->points + j*3, point->position);
point++;
}
PlaneClassify(&portal->plane);
// advance to next portal
portal++;
}
- Winding_Free(p->winding);
}
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)
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_Print("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);
+ }
}
}
}
*/
-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_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_Model_Brush_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist);
-extern void R_Model_Brush_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, int numsurfaces, const int *surfacelist);
+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);
+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, int numsurfaces, const int *surfacelist);
void Mod_Q1BSP_Load(model_t *mod, void *buffer)
{
int i, j, k;
msurface_t *surf;
int numshadowmeshtriangles;
- mod->type = mod_brush;
+ mod->type = mod_brushq1;
header = (dheader_t *)buffer;
// 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_LoadNodes(&header->lumps[LUMP_NODES]);
Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES]);
+ if (!mod->brushq1.lightdata)
+ mod->brush.LightPoint = NULL;
+
if (mod->brushq1.data_compressedpvs)
Mem_Free(mod->brushq1.data_compressedpvs);
mod->brushq1.data_compressedpvs = NULL;
// LordHavoc: this code was originally at the end of this loop, but
// has been transformed to something more readable at the start here.
- // LordHavoc: only register submodels if it is the world
- // (prevents external bsp models from replacing world submodels with
- // their own)
- if (loadmodel->isworldmodel && i)
+ 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);
// this gets altered below if sky is used
mod->DrawSky = NULL;
- mod->Draw = R_Model_Brush_Draw;
- mod->GetLightInfo = R_Model_Brush_GetLightInfo;
- mod->DrawShadowVolume = R_Model_Brush_DrawShadowVolume;
- mod->DrawLight = R_Model_Brush_DrawLight;
+ 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;
{
// we only need to have a drawsky function if it is used(usually only on world model)
if (surf->texinfo->texture->flags & SURF_DRAWSKY)
- mod->DrawSky = R_Model_Brush_DrawSky;
+ mod->DrawSky = R_Q1BSP_DrawSky;
// LordHavoc: submodels always clip, even if water
if (mod->brush.numsubmodels - 1)
surf->flags |= SURF_SOLIDCLIP;
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);
+ Mod_LoadSkinFrame(&out->skin, out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true, true);
out->surfaceparms = -1;
}
{
out->surfaceparms = flags;
if ((flags & Q3SURFACEPARM_SKY) && sky[0])
- strcpy(loadmodel->brush.skybox, sky);
+ {
+ // quake3 seems to append a _ to the skybox name, so this must do so as well
+ snprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", sky);
+ }
}
}
}
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))
loadmodel->brushq3.data_brushes = out;
loadmodel->brushq3.num_brushes = count;
- temp1 = Winding_New(64);
- temp2 = Winding_New(64);
-
maxplanes = 0;
planes = NULL;
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)
static void Mod_Q3BSP_LoadFaces(lump_t *l)
{
q3dface_t *in;
- q3mface_t *out;
+ q3msurface_t *out;
int i, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xlevel, ylevel, row0, row1, x, y, *e, finalvertices, finaltriangles;
//int *originalelement3i;
//int *originalneighbor3i;
//originalneighbor3i = out->data_neighbor3i;
*/
// convert patch to Q3FACETYPE_MESH
- xlevel = QuadraticSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
- ylevel = QuadraticSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
+ xlevel = QuadraticBSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
+ ylevel = QuadraticBSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value, 10);
// bound to user settings
xlevel = bound(r_subdivisions_minlevel.integer, xlevel, r_subdivisions_maxlevel.integer);
ylevel = bound(r_subdivisions_minlevel.integer, ylevel, r_subdivisions_maxlevel.integer);
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);
+ QuadraticBSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_vertex3f);
+ QuadraticBSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordtexture2f, out->data_texcoordtexture2f);
+ QuadraticBSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 2, originaltexcoordlightmap2f, out->data_texcoordlightmap2f);
+ QuadraticBSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 4, originalcolor4f, out->data_color4f);
// generate elements
e = out->data_element3i;
for (y = 0;y < finalheight - 1;y++)
// q3map does not put in collision brushes for curves... ugh
// build the lower quality collision geometry
out->collisions = true;
- xlevel = QuadraticSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
- ylevel = QuadraticSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
+ xlevel = QuadraticBSplinePatchSubdivisionLevelOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
+ ylevel = QuadraticBSplinePatchSubdivisionLevelOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value, 10);
// bound to user settings
xlevel = bound(r_subdivisions_collision_minlevel.integer, xlevel, r_subdivisions_collision_maxlevel.integer);
ylevel = bound(r_subdivisions_collision_minlevel.integer, ylevel, r_subdivisions_collision_maxlevel.integer);
out->data_collisionelement3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
out->num_collisionvertices = finalvertices;
out->num_collisiontriangles = finaltriangles;
- QuadraticSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_collisionvertex3f);
+ QuadraticBSplinePatchSubdivideFloatBuffer(patchsize[0], patchsize[1], xlevel, ylevel, 3, originalvertex3f, out->data_collisionvertex3f);
// generate elements
e = out->data_collisionelement3i;
for (y = 0;y < finalheight - 1;y++)
static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
{
int *in;
- q3mface_t **out;
+ q3msurface_t **out;
int i, n, count;
in = (void *)(mod_base + l->fileofs);
int i, startside, endside;
float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
q3mleaf_t *leaf;
- q3mface_t *face;
+ q3msurface_t *face;
colbrushf_t *brush;
if (startfrac > trace->realfraction)
return;
float nodesegmentmins[3], nodesegmentmaxs[3];
q3mleaf_t *leaf;
colbrushf_t *brush;
- q3mface_t *face;
+ q3msurface_t *face;
/*
// find which nodes the line is in and recurse for them
while (node->plane)
colbrushf_t *thisbrush_start, *thisbrush_end;
matrix4x4_t startmatrix, endmatrix;
static int markframe = 0;
- q3mface_t *face;
+ q3msurface_t *face;
memset(trace, 0, sizeof(*trace));
trace->fraction = 1;
trace->realfraction = 1;
else
{
// box crosses plane, take one path and remember the other
- nodestack[nodestackindex++] = node->children[0];
+ if (nodestackindex < 1024)
+ nodestack[nodestackindex++] = node->children[0];
node = node->children[1];
}
}
if ((pvs == NULL || CHECKPVSBIT(pvs, leaf->clusterindex)))
{
int marksurfacenum;
- q3mface_t *surf;
+ q3msurface_t *surf;
if (maxleafs && *numleafs < maxleafs)
leaflist[(*numleaf)++] = leaf;
if (maxsurfaces)
}
*/
+void Mod_Q3BSP_RecursiveFindNumLeafs(q3mnode_t *node)
+{
+ int numleafs;
+ while (node->plane)
+ {
+ Mod_Q3BSP_RecursiveFindNumLeafs(node->children[0]);
+ node = node->children[1];
+ }
+ numleafs = ((q3mleaf_t *)node - loadmodel->brushq3.data_leafs) + 1;
+ if (loadmodel->brushq3.num_leafs < numleafs)
+ loadmodel->brushq3.num_leafs = numleafs;
+}
+
extern void R_Q3BSP_DrawSky(struct entity_render_s *ent);
extern void R_Q3BSP_Draw(struct entity_render_s *ent);
extern void R_Q3BSP_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);
int i, j, numshadowmeshtriangles;
q3dheader_t *header;
float corner[3], yawradius, modelradius;
- q3mface_t *face;
+ q3msurface_t *face;
mod->type = mod_brushq3;
mod->numframes = 1;
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_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, face->data_vertex3f, NULL, NULL, NULL, NULL, face->num_triangles, face->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->brushq3.num_leafs = 0;
+ Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brushq3.data_nodes);
+
+ mod = loadmodel;
for (i = 0;i < loadmodel->brushq3.num_models;i++)
{
- if (i == 0)
- mod = loadmodel;
- else
+ 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
projects / xonotic / darkplaces.git / blobdiff