}
//#endif
-static void Mod_Q1BSP_TracePoint(struct model_s *model, int frame, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
+static void Mod_Q1BSP_TracePoint(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
{
RecursiveHullCheckTraceInfo_t rhc;
Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
}
-static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q1BSP_TraceLine(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
{
RecursiveHullCheckTraceInfo_t rhc;
if (VectorCompare(start, end))
{
- Mod_Q1BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask);
+ Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
return;
}
#endif
}
-static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q1BSP_TraceBox(struct model_s *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
{
// this function currently only supports same size start and end
double boxsize[3];
if (VectorCompare(boxmins, boxmaxs))
{
if (VectorCompare(start, end))
- Mod_Q1BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask);
+ Mod_Q1BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
else
- Mod_Q1BSP_TraceLine(model, frame, trace, start, end, hitsupercontentsmask);
+ Mod_Q1BSP_TraceLine(model, frameblend, skeleton, trace, start, end, hitsupercontentsmask);
return;
}
static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end)
{
trace_t trace;
- model->TraceLine(model, 0, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
+ model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
return trace.fraction == 1;
}
tx->reflectfactor = 1;
Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1);
tx->r_water_wateralpha = 1;
+ tx->specularscalemod = 1;
+ tx->specularpowermod = 1;
}
if (!m)
Mem_Free(freepixels);
}
else if (mtdata) // texture included
- skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
+ skinframe = R_SkinFrame_LoadInternalQuake(tx->name, TEXF_PRECACHE | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height);
}
// if skinframe is still NULL the "missing" texture will be used
if (skinframe)
tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
else
tx->basematerialflags |= MATERIALFLAG_WATERSCROLL | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW | MATERIALFLAG_WATERALPHA | MATERIALFLAG_WATERSHADER;
- if (tx->skinframes[0] && tx->skinframes[0]->fog)
+ if (tx->skinframes[0] && tx->skinframes[0]->hasalpha)
tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
}
else if (!strncmp(tx->name, "mirror", 6)) // Tenebrae
tx->basematerialflags = MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
else if (!strcmp(tx->name, "caulk"))
tx->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
- else if (tx->skinframes[0] && tx->skinframes[0]->fog)
+ else if (tx->skinframes[0] && tx->skinframes[0]->hasalpha)
tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
// start out with no animation
tx->currentframe = tx;
tx->currentskinframe = tx->skinframes[0];
+ tx->specularscalemod = 1; // not supported here
+ tx->specularpowermod = 1; // not supported here
}
}
}
#endif
-/* Maximum size of a single LM */
-#define MAX_SINGLE_LM_SIZE 256
-
-struct alloc_lm_row
-{
- int rowY;
- int currentX;
-};
-
-struct alloc_lm_state
-{
- int currentY;
- struct alloc_lm_row rows[MAX_SINGLE_LM_SIZE];
-};
-
-static void init_alloc_lm_state (struct alloc_lm_state* state)
-{
- int r;
-
- state->currentY = 0;
- for (r = 0; r < MAX_SINGLE_LM_SIZE; r++)
- {
- state->rows[r].currentX = 0;
- state->rows[r].rowY = -1;
- }
-}
-
-static qboolean Mod_Q1BSP_AllocLightmapBlock(struct alloc_lm_state* state, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
-{
- struct alloc_lm_row* row;
- int r;
-
- row = &(state->rows[blockheight]);
- if ((row->rowY < 0) || (row->currentX + blockwidth > totalwidth))
- {
- if (state->currentY + blockheight <= totalheight)
- {
- row->rowY = state->currentY;
- row->currentX = 0;
- state->currentY += blockheight;
- }
- else
- {
- /* See if we can stuff the block into a higher row */
- row = NULL;
- for (r = blockheight; r < MAX_SINGLE_LM_SIZE; r++)
- {
- if ((state->rows[r].rowY >= 0)
- && (state->rows[r].currentX + blockwidth <= totalwidth))
- {
- row = &(state->rows[r]);
- break;
- }
- }
- if (row == NULL) return false;
- }
- }
- *outy = row->rowY;
- *outx = row->currentX;
- row->currentX += blockwidth;
-
- return true;
-}
-
-extern cvar_t gl_max_size;
+extern cvar_t gl_max_lightmapsize;
static void Mod_Q1BSP_LoadFaces(lump_t *l)
{
dface_t *in;
lightmaptexture = NULL;
deluxemaptexture = r_texture_blanknormalmap;
lightmapnumber = 1;
- lightmapsize = max(256, gl_max_size.integer);
+ lightmapsize = bound(256, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d);
totallightmapsamples = 0;
totalverts = 0;
// small maps (such as ammo boxes especially) don't need big lightmap
// textures, so this code tries to guess a good size based on
// totallightmapsamples (size of the lightmaps lump basically), as well as
- // trying to max out the gl_max_size if there is a lot of lightmap data to
- // store
+ // trying to max out the size if there is a lot of lightmap data to store
// additionally, never choose a lightmapsize that is smaller than the
// largest surface encountered (as it would fail)
i = lightmapsize;
- for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < gl_max_size.integer) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2)
+ for (lightmapsize = 64; (lightmapsize < i) && (lightmapsize < bound(128, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d)) && (totallightmapsamples > lightmapsize*lightmapsize); lightmapsize*=2)
;
// now that we've decided the lightmap texture size, we can do the rest
if (cls.state != ca_dedicated)
{
int stainmapsize = 0;
- struct alloc_lm_state allocState;
+ mod_alloclightmap_state_t allocState;
+ Mod_AllocLightmap_Init(&allocState, lightmapsize, lightmapsize);
for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
{
int i, iu, iv, lightmapx = 0, lightmapy = 0;
tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
stainmapsize += ssize * tsize * 3;
- if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
+ if (!lightmaptexture || !Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy))
{
// allocate a texture pool if we need it
if (loadmodel->texturepool == NULL)
if (loadmodel->brushq1.nmaplightdata)
deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
lightmapnumber++;
- init_alloc_lm_state (&allocState);
- Mod_Q1BSP_AllocLightmapBlock(&allocState, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
+ Mod_AllocLightmap_Reset(&allocState);
+ Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy);
}
surface->lightmaptexture = lightmaptexture;
surface->deluxemaptexture = deluxemaptexture;
}
portal_t;
-static portal_t *portalchain;
-
-/*
-===========
-AllocPortal
-===========
-*/
-static portal_t *AllocPortal(void)
-{
- portal_t *p;
- p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
- p->chain = portalchain;
- portalchain = p;
- return p;
-}
-
-static void FreePortal(portal_t *p)
-{
- Mem_Free(p);
-}
+static memexpandablearray_t portalarray;
static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
{
static void Mod_Q1BSP_FinalizePortals(void)
{
- int i, j, numportals, numpoints;
- portal_t *p, *pnext;
+ int i, j, numportals, numpoints, portalindex, portalrange = Mem_ExpandableArray_IndexRange(&portalarray);
+ portal_t *p;
mportal_t *portal;
mvertex_t *point;
mleaf_t *leaf, *endleaf;
VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000);
VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
}
- p = portalchain;
numportals = 0;
numpoints = 0;
- while (p)
+ for (portalindex = 0;portalindex < portalrange;portalindex++)
{
+ p = (portal_t*)Mem_ExpandableArray_RecordAtIndex(&portalarray, portalindex);
+ if (!p)
+ continue;
// 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->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->numpoints * 2;
}
- p = p->chain;
}
loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
loadmodel->brush.num_portals = numportals;
// process all portals in the global portal chain, while freeing them
portal = loadmodel->brush.data_portals;
point = loadmodel->brush.data_portalpoints;
- p = portalchain;
- portalchain = NULL;
- while (p)
+ for (portalindex = 0;portalindex < portalrange;portalindex++)
{
- pnext = p->chain;
-
+ p = (portal_t*)Mem_ExpandableArray_RecordAtIndex(&portalarray, portalindex);
+ if (!p)
+ continue;
if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
{
// note: this check must match the one above or it will usually corrupt memory
}
}
}
- FreePortal(p);
- p = pnext;
}
// now recalculate the node bounding boxes from the leafs
Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode);
// create the new portal by generating a polygon for the node plane,
// and clipping it by all of the other portals(which came from nodes above this one)
- nodeportal = AllocPortal();
+ nodeportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray);
nodeportal->plane = *plane;
// TODO: calculate node bounding boxes during recursion and calculate a maximum plane size accordingly to improve precision (as most maps do not need 1 billion unit plane polygons)
}
// the portal is split
- splitportal = AllocPortal();
+ splitportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray);
temp = splitportal->chain;
*splitportal = *portal;
splitportal->chain = temp;
static void Mod_Q1BSP_MakePortals(void)
{
- portalchain = NULL;
+ Mem_ExpandableArray_NewArray(&portalarray, loadmodel->mempool, sizeof(portal_t), 1020*1024/sizeof(portal_t));
Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode);
Mod_Q1BSP_FinalizePortals();
+ Mem_ExpandableArray_FreeArray(&portalarray);
}
//Returns PVS data for a given point
mod->Draw = R_Q1BSP_Draw;
mod->DrawDepth = R_Q1BSP_DrawDepth;
mod->DrawDebug = R_Q1BSP_DrawDebug;
+ mod->DrawPrepass = R_Q1BSP_DrawPrepass;
mod->GetLightInfo = R_Q1BSP_GetLightInfo;
mod->CompileShadowMap = R_Q1BSP_CompileShadowMap;
mod->DrawShadowMap = R_Q1BSP_DrawShadowMap;
if (!COM_ParseToken_Simple(&data, false, false))
break; // error
strlcpy(value, com_token, sizeof(value));
- if (!strcmp("gridsize", key))
+ if (!strcasecmp("gridsize", key)) // this one is case insensitive to 100% match q3map2
{
#if _MSC_VER >= 1400
#define sscanf sscanf_s
#endif
+#if 0
if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
+#else
+ VectorSet(v, 64, 64, 128);
+ if(sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) != 3)
+ Con_Printf("Mod_Q3BSP_LoadEntities: funny gridsize \"%s\" in %s, interpreting as \"%f %f %f\" to match q3map2's parsing\n", value, loadmodel->name, v[0], v[1], v[2]);
+ if (v[0] != 0 && v[1] != 0 && v[2] != 0)
+ VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
+#endif
}
else if (!strcmp("deluxeMaps", key))
{
;
// i is now 0 for 128, 1 for 256, etc
- for (power = 1;power + i <= mod_q3bsp_lightmapmergepower.integer && (size << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> (loadmodel->brushq3.deluxemapping ? 1 : 0)); power++)
+ for (power = 1;power + i <= mod_q3bsp_lightmapmergepower.integer && (size << power) <= (int)vid.maxtexturesize_2d && (1 << (power * 2)) < 4 * (count >> (loadmodel->brushq3.deluxemapping ? 1 : 0)); power++)
loadmodel->brushq3.num_lightmapmergepower = power;
loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower;
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)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_isize[0], loadmodel->brushq3.num_lightgrid_isize[1], loadmodel->brushq3.num_lightgrid_isize[2]);
+ {
+ Con_Printf("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_isize[0], loadmodel->brushq3.num_lightgrid_isize[1], loadmodel->brushq3.num_lightgrid_isize[2]);
+ return; // ignore the grid if we cannot understand it
+ }
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", (int)(count * sizeof(*in)), l->filelen);
out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
if (model->brush.submodel || mod_q3bsp_tracelineofsight_brushes.integer)
{
trace_t trace;
- model->TraceLine(model, 0, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
+ model->TraceLine(model, NULL, NULL, &trace, start, end, SUPERCONTENTS_VISBLOCKERMASK);
return trace.fraction == 1;
}
else
static int markframe = 0;
-static void Mod_Q3BSP_TracePoint(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
+static void Mod_Q3BSP_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask)
{
int i;
q3mbrush_t *brush;
Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe);
}
-static void Mod_Q3BSP_TraceLine(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q3BSP_TraceLine(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t end, int hitsupercontentsmask)
{
int i;
float segmentmins[3], segmentmaxs[3];
if (VectorCompare(start, end))
{
- Mod_Q3BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask);
+ Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask);
return;
}
Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs);
}
-static void Mod_Q3BSP_TraceBox(dp_model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
+static void Mod_Q3BSP_TraceBox(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
{
int i;
float segmentmins[3], segmentmaxs[3];
VectorAdd(start, boxmins, shiftstart);
VectorAdd(end, boxmins, shiftend);
if (VectorCompare(start, end))
- Mod_Q3BSP_TracePoint(model, frame, trace, shiftstart, hitsupercontentsmask);
+ Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, shiftstart, hitsupercontentsmask);
else
{
- Mod_Q3BSP_TraceLine(model, frame, trace, shiftstart, shiftend, hitsupercontentsmask);
+ Mod_Q3BSP_TraceLine(model, frameblend, skeleton, trace, shiftstart, shiftend, hitsupercontentsmask);
VectorSubtract(trace->endpos, boxmins, trace->endpos);
}
return;
mod->Draw = R_Q1BSP_Draw;
mod->DrawDepth = R_Q1BSP_DrawDepth;
mod->DrawDebug = R_Q1BSP_DrawDebug;
+ mod->DrawPrepass = R_Q1BSP_DrawPrepass;
mod->GetLightInfo = R_Q1BSP_GetLightInfo;
mod->CompileShadowMap = R_Q1BSP_CompileShadowMap;
mod->DrawShadowMap = R_Q1BSP_DrawShadowMap;
loadmodel->brush.num_leafs = 0;
Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
+ if (loadmodel->brush.numsubmodels)
+ loadmodel->brush.submodels = (dp_model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(dp_model_t *));
+
mod = loadmodel;
for (i = 0;i < loadmodel->brush.numsubmodels;i++)
{
mod->brush.AmbientSoundLevelsForPoint = NULL;
}
mod->brush.submodel = i;
+ if (loadmodel->brush.submodels)
+ loadmodel->brush.submodels[i] = mod;
// make the model surface list (used by shadowing/lighting)
mod->firstmodelsurface = mod->brushq3.data_models[i].firstface;
loadmodel->Draw = R_Q1BSP_Draw;
loadmodel->DrawDepth = R_Q1BSP_DrawDepth;
loadmodel->DrawDebug = R_Q1BSP_DrawDebug;
+ loadmodel->DrawPrepass = R_Q1BSP_DrawPrepass;
loadmodel->GetLightInfo = R_Q1BSP_GetLightInfo;
loadmodel->CompileShadowMap = R_Q1BSP_CompileShadowMap;
loadmodel->DrawShadowMap = R_Q1BSP_DrawShadowMap;
projects / xonotic / darkplaces.git / blobdiff