#include "quakedef.h"
-byte mod_novis[(MAX_MAP_LEAFS + 7)/ 8];
+qbyte mod_novis[(MAX_MAP_LEAFS + 7)/ 8];
cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128"};
cvar_t halflifebsp = {0, "halflifebsp", "0"};
Mod_DecompressVis
===================
*/
-static byte *Mod_DecompressVis (byte *in, model_t *model)
+static qbyte *Mod_DecompressVis (qbyte *in, model_t *model)
{
- static byte decompressed[MAX_MAP_LEAFS/8];
- int c;
- byte *out;
- int row;
+ static qbyte decompressed[MAX_MAP_LEAFS/8];
+ int c;
+ qbyte *out;
+ int row;
row = (model->numleafs+7)>>3;
out = decompressed;
return decompressed;
}
-byte *Mod_LeafPVS (mleaf_t *leaf, model_t *model)
+qbyte *Mod_LeafPVS (mleaf_t *leaf, model_t *model)
{
if (r_novis.integer || leaf == model->leafs || leaf->compressed_vis == NULL)
return mod_novis;
void Mod_SetupNoTexture(void)
{
- int x, y;
- byte pix[16][16][4];
+ int x, y;
+ qbyte pix[16][16][4];
for (y = 0;y < 16;y++)
{
miptex_t *dmiptex;
texture_t *tx, *tx2, *anims[10], *altanims[10];
dmiptexlump_t *m;
- byte *data, *mtdata, *data2;
+ qbyte *data, *mtdata, *data2;
char name[256];
Mod_SetupNoTexture();
dofs[i] = LittleLong(dofs[i]);
if (dofs[i] == -1)
continue;
- dmiptex = (miptex_t *)((byte *)m + dofs[i]);
+ dmiptex = (miptex_t *)((qbyte *)m + dofs[i]);
mtwidth = LittleLong (dmiptex->width);
mtheight = LittleLong (dmiptex->height);
mtdata = NULL;
// texture included
if (j < 40 || j + mtwidth * mtheight > l->filelen)
Host_Error ("Texture %s is corrupt or incomplete\n", dmiptex->name);
- mtdata = (byte *)dmiptex + j;
+ mtdata = (qbyte *)dmiptex + j;
}
if ((mtwidth & 15) || (mtheight & 15))
static void Mod_LoadLighting (lump_t *l)
{
int i;
- byte *in, *out, *data;
- byte d;
+ qbyte *in, *out, *data, d;
char litfilename[1024];
loadmodel->lightdata = NULL;
if (loadmodel->ishlbsp) // LordHavoc: load the colored lighting data straight
strcpy(litfilename, loadmodel->name);
COM_StripExtension(litfilename, litfilename);
strcat(litfilename, ".lit");
- data = (byte*) COM_LoadFile (litfilename, false);
+ data = (qbyte*) COM_LoadFile (litfilename, false);
if (data)
{
if (loadsize > 8 && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
if (mesh->numtriangles < 1)
Host_Error("Mod_GenerateWarpMesh: no triangles?\n");
mesh->index = Mem_Alloc(loadmodel->mempool, mesh->numtriangles * sizeof(int[3]) + mesh->numverts * sizeof(surfvertex_t));
- mesh->vertex = (surfvertex_t *)((long) mesh->index + mesh->numtriangles * sizeof(int[3]));
+ mesh->vertex = (surfvertex_t *)((qbyte *) mesh->index + mesh->numtriangles * sizeof(int[3]));
memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
for (i = 0;i < mesh->numtriangles;i++)
mesh->numverts = surf->poly_numverts;
mesh->numtriangles = surf->poly_numverts - 2;
mesh->index = Mem_Alloc(loadmodel->mempool, mesh->numtriangles * sizeof(int[3]) + mesh->numverts * sizeof(surfvertex_t));
- mesh->vertex = (surfvertex_t *)((long) mesh->index + mesh->numtriangles * sizeof(int[3]));
+ mesh->vertex = (surfvertex_t *)((qbyte *) mesh->index + mesh->numtriangles * sizeof(int[3]));
memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
index = mesh->index;
if (r_miplightmaps.integer)
{
surf->lightmaptexturestride = (surf->extents[0]>>4)+1;
- surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP/* | TEXF_PRECACHE*/, NULL, NULL, 0);
+ surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_MIPMAP | TEXF_PRECACHE, NULL, NULL, 0);
}
else
{
surf->lightmaptexturestride = R_CompatibleFragmentWidth((surf->extents[0]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, 0);
- surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT/* | TEXF_PRECACHE*/, NULL, NULL, 0);
+ surf->lightmaptexture = R_ProceduralTexture(loadmodel->texturepool, NULL, surf->lightmaptexturestride, (surf->extents[1]>>4)+1, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_PRECACHE, NULL, NULL, 0);
}
// surf->lightmaptexture = R_LoadTexture(loadmodel->texturepool, va("lightmap%08x", lightmapnum), surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FRAGMENT | TEXF_PRECACHE);
// surf->lightmaptexture = R_LoadTexture(loadmodel->texturepool, va("lightmap%08x", lightmapnum), surf->lightmaptexturestride, (surf->extents[1]>>4)+1, NULL, loadmodel->lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_PRECACHE);
- R_GetFragmentLocation(surf->lightmaptexture, NULL, NULL, &xbase, &ybase, &xscale, &yscale);
+ R_FragmentLocation(surf->lightmaptexture, NULL, NULL, &xbase, &ybase, &xscale, &yscale);
xscale = (xscale - xbase) * 16.0 / ((surf->extents[0] & ~15) + 16);
yscale = (yscale - ybase) * 16.0 / ((surf->extents[1] & ~15) + 16);
mesh->numverts = surf->poly_numverts;
mesh->numtriangles = surf->poly_numverts - 2;
mesh->index = Mem_Alloc(loadmodel->mempool, mesh->numtriangles * sizeof(int[3]) + mesh->numverts * sizeof(surfvertex_t));
- mesh->vertex = (surfvertex_t *)((long) mesh->index + mesh->numtriangles * sizeof(int[3]));
+ mesh->vertex = (surfvertex_t *)((qbyte *) mesh->index + mesh->numtriangles * sizeof(int[3]));
memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
index = mesh->index;
mesh->numverts = surf->poly_numverts;
mesh->numtriangles = surf->poly_numverts - 2;
mesh->index = Mem_Alloc(loadmodel->mempool, mesh->numtriangles * sizeof(int[3]) + mesh->numverts * sizeof(surfvertex_t));
- mesh->vertex = (surfvertex_t *)((long) mesh->index + mesh->numtriangles * sizeof(int[3]));
+ mesh->vertex = (surfvertex_t *)((qbyte *) mesh->index + mesh->numtriangles * sizeof(int[3]));
memset(mesh->vertex, 0, mesh->numverts * sizeof(surfvertex_t));
index = mesh->index;
{
dface_t *in;
msurface_t *out;
- int i, count, surfnum;
- int planenum, side;
+ int i, count, surfnum, planenum, side, ssize, tsize;
in = (void *)(mod_base + l->fileofs);
if (l->filelen % sizeof(*in))
CalcSurfaceExtents (out);
+ ssize = (out->extents[0] >> 4) + 1;
+ tsize = (out->extents[1] >> 4) + 1;
+
// lighting info
for (i = 0;i < MAXLIGHTMAPS;i++)
out->styles[i] = in->styles[i];
{
// qbsp couldn't find the texture for this surface, but it was either turb or sky... assume turb
out->shader = &Cshader_water;
+ out->shader = &Cshader_water;
out->samples = NULL;
Mod_GenerateWarpMesh (out);
}
out->samples = NULL;
Mod_GenerateVertexMesh(out);
}
- else if (out->extents[0] < r_vertexsurfacesthreshold.integer && out->extents[1] < r_vertexsurfacesthreshold.integer)
- {
- out->shader = &Cshader_wall_vertex;
- Mod_GenerateVertexLitMesh(out);
- }
else
{
- out->shader = &Cshader_wall_lightmap;
- Mod_GenerateLightmappedMesh(out);
+ // stainmap for permanent marks on walls
+ out->stainsamples = Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
+ // clear to white
+ memset(out->stainsamples, 255, ssize * tsize * 3);
+ if (out->extents[0] < r_vertexsurfacesthreshold.integer && out->extents[1] < r_vertexsurfacesthreshold.integer)
+ {
+ out->shader = &Cshader_wall_vertex;
+ Mod_GenerateVertexLitMesh(out);
+ }
+ else
+ {
+ out->shader = &Cshader_wall_lightmap;
+ Mod_GenerateLightmappedMesh(out);
+ }
}
}
}
a = *((const msurface_t **)voida);
b = *((const msurface_t **)voidb);
if (a->shader != b->shader)
- return (long) a->shader - (long) b->shader;
+ return (qbyte *) a->shader - (qbyte *) b->shader;
if (a->texinfo->texture != b->texinfo->texture);
return a->texinfo->texture - b->texinfo->texture;
return 0;
hull->clip_maxs[0] = 16;
hull->clip_maxs[1] = 16;
hull->clip_maxs[2] = 36;
+ VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
hull = &loadmodel->hulls[2];
hull->clipnodes = out;
hull->clip_maxs[0] = 32;
hull->clip_maxs[1] = 32;
hull->clip_maxs[2] = 32;
+ VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
hull = &loadmodel->hulls[3];
hull->clipnodes = out;
hull->clip_maxs[0] = 16;
hull->clip_maxs[1] = 16;
hull->clip_maxs[2] = 18;
+ VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
}
else
{
hull->clip_maxs[0] = 16;
hull->clip_maxs[1] = 16;
hull->clip_maxs[2] = 32;
+ VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
hull = &loadmodel->hulls[2];
hull->clipnodes = out;
hull->clip_maxs[0] = 32;
hull->clip_maxs[1] = 32;
hull->clip_maxs[2] = 64;
+ VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
}
for (i=0 ; i<count ; i++, out++, in++)
endleaf = leaf + loadmodel->numleafs;
for (;leaf < endleaf;leaf++)
{
- VectorSet( 2000000000, 2000000000, 2000000000, leaf->mins);
- VectorSet(-2000000000, -2000000000, -2000000000, leaf->maxs);
+ VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000);
+ VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
}
p = portalchain;
while(p)
}
loadmodel->portals = Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
loadmodel->numportals = numportals;
- loadmodel->portalpoints = (void *) ((long) loadmodel->portals + numportals * sizeof(mportal_t));
+ loadmodel->portalpoints = (void *) ((qbyte *) loadmodel->portals + numportals * sizeof(mportal_t));
loadmodel->numportalpoints = numpoints;
// clear all leaf portal chains
for (i = 0;i < loadmodel->numleafs;i++)
dheader_t *header;
dmodel_t *bm;
mempool_t *mainmempool;
+ char *loadname;
mod->type = mod_brush;
Cvar_SetValue("halflifebsp", mod->ishlbsp);
// swap all the lumps
- mod_base = (byte *)header;
+ mod_base = (qbyte *)header;
for (i=0 ; i<sizeof(dheader_t)/4 ; i++)
((int *)header)[i] = LittleLong ( ((int *)header)[i]);
mod->numframes = 2; // regular and alternate animation
mainmempool = mod->mempool;
+ loadname = mod->name;
//
// set up the submodels (FIXME: this is confusing)
mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
// mod->modelradius = modelradius;
+ // LordHavoc: check for empty submodels (lacrima.bsp has such a glitch)
+ if (mod->normalmins[0] > mod->normalmaxs[0] || mod->normalmins[1] > mod->normalmaxs[1] || mod->normalmins[2] > mod->normalmaxs[2])
+ {
+ Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadname);
+ VectorClear(mod->normalmins);
+ VectorClear(mod->normalmaxs);
+ VectorClear(mod->yawmins);
+ VectorClear(mod->yawmaxs);
+ VectorClear(mod->rotatedmins);
+ VectorClear(mod->rotatedmaxs);
+ //mod->modelradius = 0;
+ }
// VectorCopy (bm->maxs, mod->maxs);
// VectorCopy (bm->mins, mod->mins);
projects / xonotic / darkplaces.git / blobdiff