X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=model_brush.c;h=d371c7df90bf059c08341369b73c0cb98fd65e52;hb=a958e8cfe4940aaceefe6a66b0a2ff38f85b89f3;hp=a245384bde33b5a40b8e96cff154f797161c8d45;hpb=d2412a2c1915928f9b2b7025428a25cb4084e3a3;p=xonotic%2Fdarkplaces.git diff --git a/model_brush.c b/model_brush.c index a245384b..d371c7df 100644 --- a/model_brush.c +++ b/model_brush.c @@ -39,13 +39,18 @@ cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess" cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"}; cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"}; cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"}; -cvar_t mod_q3bsp_curves_collisions_stride = {0, "mod_q3bsp_curves_collisions_stride", "16", "collisions against curves: optimize performance by doing a combined collision check for this triangle amount first"}; -cvar_t mod_q3bsp_curves_stride = {0, "mod_q3bsp_curves_stride", "16", "particle effect collisions against curves: optimize performance by doing a combined collision check for this triangle amount first"}; +cvar_t mod_q3bsp_curves_collisions_stride = {0, "mod_q3bsp_curves_collisions_stride", "16", "collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; +cvar_t mod_q3bsp_curves_stride = {0, "mod_q3bsp_curves_stride", "16", "particle effect collisions against curves: optimize performance by doing a combined collision check for this triangle amount first (-1 avoids any box tests)"}; cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"}; cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"}; cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."}; cvar_t mod_q3bsp_nolightmaps = {CVAR_SAVE, "mod_q3bsp_nolightmaps", "0", "do not load lightmaps in Q3BSP maps (to save video RAM, but be warned: it looks ugly)"}; cvar_t mod_q3bsp_tracelineofsight_brushes = {0, "mod_q3bsp_tracelineofsight_brushes", "0", "enables culling of entities behind detail brushes, curves, etc"}; +cvar_t mod_q3shader_default_offsetmapping = {CVAR_SAVE, "mod_q3shader_default_offsetmapping", "1", "use offsetmapping by default on all surfaces"}; + +cvar_t mod_q1bsp_polygoncollisions = {0, "mod_q1bsp_polygoncollisions", "0", "disables use of precomputed cliphulls and instead collides with polygons (uses Bounding Interval Hierarchy optimizations)"}; +cvar_t mod_collision_bih = {0, "mod_collision_bih", "1", "enables use of generated Bounding Interval Hierarchy tree instead of compiled bsp tree in collision code"}; +cvar_t mod_recalculatenodeboxes = {0, "mod_recalculatenodeboxes", "1", "enables use of generated node bounding boxes based on BSP tree portal reconstruction, rather than the node boxes supplied by the map compiler"}; static texture_t mod_q1bsp_texture_solid; static texture_t mod_q1bsp_texture_sky; @@ -75,6 +80,10 @@ void Mod_BrushInit(void) Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower); Cvar_RegisterVariable(&mod_q3bsp_nolightmaps); Cvar_RegisterVariable(&mod_q3bsp_tracelineofsight_brushes); + Cvar_RegisterVariable(&mod_q3shader_default_offsetmapping); + Cvar_RegisterVariable(&mod_q1bsp_polygoncollisions); + Cvar_RegisterVariable(&mod_collision_bih); + Cvar_RegisterVariable(&mod_recalculatenodeboxes); memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid)); strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name)); @@ -522,17 +531,17 @@ static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *in surface = info->model->data_surfaces + *mark; if (surface->texture->supercontents & SUPERCONTENTS_SOLID) { - if(surface->num_bboxstride) + if(surface->deprecatedq3num_bboxstride > 0) { int i, cnt, tri; - cnt = (surface->num_triangles + surface->num_bboxstride - 1) / surface->num_bboxstride; + cnt = (surface->num_triangles + surface->deprecatedq3num_bboxstride - 1) / surface->deprecatedq3num_bboxstride; for(i = 0; i < cnt; ++i) { - if(BoxesOverlap(surface->data_bbox6f + i * 6, surface->data_bbox6f + i * 6 + 3, info->absmin, info->absmax)) + if(BoxesOverlap(surface->deprecatedq3data_bbox6f + i * 6, surface->deprecatedq3data_bbox6f + i * 6 + 3, info->absmin, info->absmax)) { - for(k = 0; k < surface->num_bboxstride; ++k) + for(k = 0; k < surface->deprecatedq3num_bboxstride; ++k) { - tri = i * surface->num_bboxstride + k; + tri = i * surface->deprecatedq3num_bboxstride + k; if(tri >= surface->num_triangles) break; Mod_Q1BSP_FindNonSolidLocation_r_Triangle(info, surface, tri); @@ -853,7 +862,7 @@ static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, i } //#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; @@ -869,13 +878,13 @@ static void Mod_Q1BSP_TracePoint(struct model_s *model, int frame, trace_t *trac 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; } @@ -921,7 +930,7 @@ static void Mod_Q1BSP_TraceLine(struct model_s *model, int frame, trace_t *trace #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]; @@ -930,9 +939,9 @@ static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, 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; } @@ -1017,11 +1026,13 @@ static int Mod_Q1BSP_PointSuperContents(struct model_s *model, int frame, const return Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num); } -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, int boxq3surfaceflags, texture_t *boxtexture) +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, int boxq3surfaceflags, const texture_t *boxtexture) { #if 1 colbrushf_t cbox; colplanef_t cbox_planes[6]; + cbox.isaabb = true; + cbox.hasaabbplanes = true; cbox.supercontents = boxsupercontents; cbox.numplanes = 6; cbox.numpoints = 0; @@ -1121,7 +1132,7 @@ void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cm #endif } -void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture) +void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, const texture_t *boxtexture) { memset(trace, 0, sizeof(trace_t)); trace->fraction = 1; @@ -1140,7 +1151,7 @@ void Collision_ClipTrace_Point(trace_t *trace, const vec3_t cmins, const vec3_t 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; } @@ -1207,7 +1218,7 @@ loc0: surface = model->data_surfaces + node->firstsurface; for (i = 0;i < node->numsurfaces;i++, surface++) { - if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples) + if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo || !surface->lightmapinfo->samples) continue; // no lightmaps // location we want to sample in the lightmap @@ -1321,8 +1332,11 @@ A sky texture is 256*128, with the right side being a masked overlay */ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel) { - int i, j; - unsigned solidpixels[128*128], alphapixels[128*128]; + int x, y; + int w = width/2; + int h = height; + unsigned *solidpixels = Mem_Alloc(tempmempool, w*h*sizeof(unsigned char[4])); + unsigned *alphapixels = Mem_Alloc(tempmempool, w*h*sizeof(unsigned char[4])); // allocate a texture pool if we need it if (loadmodel->texturepool == NULL && cls.state != ca_dedicated) @@ -1330,12 +1344,12 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp if (bytesperpixel == 4) { - for (i = 0;i < 128;i++) + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128]; - alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j]; + solidpixels[y*w+x] = ((unsigned *)src)[y*width+x+w]; + alphapixels[y*w+x] = ((unsigned *)src)[y*width+x]; } } } @@ -1351,33 +1365,35 @@ void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesp } bgra; r = g = b = 0; - for (i = 0;i < 128;i++) + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - p = src[i*256 + j + 128]; + p = src[x*width+y+w]; r += palette_rgb[p][0]; g += palette_rgb[p][1]; b += palette_rgb[p][2]; } } - bgra.b[2] = r/(128*128); - bgra.b[1] = g/(128*128); - bgra.b[0] = b/(128*128); + bgra.b[2] = r/(w*h); + bgra.b[1] = g/(w*h); + bgra.b[0] = b/(w*h); bgra.b[3] = 0; - for (i = 0;i < 128;i++) + for (y = 0;y < h;y++) { - for (j = 0;j < 128;j++) + for (x = 0;x < w;x++) { - solidpixels[(i*128) + j] = palette_bgra_complete[src[i*256 + j + 128]]; - p = src[i*256 + j]; - alphapixels[(i*128) + j] = p ? palette_bgra_complete[p] : bgra.i; + solidpixels[y*w+x] = palette_bgra_complete[src[y*width+x+w]]; + p = src[y*width+x]; + alphapixels[y*w+x] = p ? palette_bgra_complete[p] : bgra.i; } } } - loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_BGRA, TEXF_PRECACHE, NULL); - loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PRECACHE, NULL); + loadmodel->brush.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", 0 , (unsigned char *) solidpixels, w, h); + loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA, (unsigned char *) alphapixels, w, h); + Mem_Free(solidpixels); + Mem_Free(alphapixels); } static void Mod_Q1BSP_LoadTextures(lump_t *l) @@ -1452,6 +1468,10 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) tx->reflectfactor = 1; Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1); tx->r_water_wateralpha = 1; + tx->offsetmapping = OFFSETMAPPING_OFF; + tx->offsetscale = 1; + tx->specularscalemod = 1; + tx->specularpowermod = 1; } if (!m) @@ -1556,10 +1576,10 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) if (cls.state != ca_dedicated) { // LordHavoc: HL sky textures are entirely different than quake - if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128) + if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == mtheight * 2) { - data = loadimagepixelsbgra(tx->name, false, false); - if (data && image_width == 256 && image_height == 128) + data = loadimagepixelsbgra(tx->name, false, false, r_texture_convertsRGB_skin.integer); + if (data && image_width == image_height * 2) { R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4); Mem_Free(data); @@ -1569,9 +1589,9 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) } else { - skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_ALPHA | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); if (!skinframe) - skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); + skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_ALPHA | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS, false); if (!skinframe) { // did not find external texture, load it from the bsp or wad3 @@ -1588,13 +1608,13 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) { tx->width = image_width; tx->height = image_height; - skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height); + skinframe = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_ALPHA | TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0), pixels, image_width, image_height); } if (freepixels) 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_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) @@ -1609,7 +1629,7 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) { // replace the texture with transparent black Vector4Set(zero, 128, 128, 128, 128); - tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_ALPHA, zero, 1, 1); + tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_MIPMAP | TEXF_ALPHA, zero, 1, 1); tx->basematerialflags |= MATERIALFLAG_NOSHADOW | MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_REFLECTION; } else if (!strncmp(tx->name,"*lava",5) @@ -1618,20 +1638,20 @@ static void Mod_Q1BSP_LoadTextures(lump_t *l) 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 { // replace the texture with black - tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, TEXF_PRECACHE, zero, 1, 1); + tx->skinframes[0] = R_SkinFrame_LoadInternalBGRA(tx->name, 0, zero, 1, 1); tx->basematerialflags |= MATERIALFLAG_REFLECTION; } else if (!strncmp(tx->name, "sky", 3)) 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 @@ -2221,71 +2241,7 @@ static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface) } #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; @@ -2303,6 +2259,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) loadmodel->num_surfaces = count; + loadmodel->brushq1.firstrender = true; loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char)); totalverts = 0; @@ -2318,8 +2275,8 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) lightmaptexture = NULL; deluxemaptexture = r_texture_blanknormalmap; - lightmapnumber = 1; - lightmapsize = max(256, gl_max_size.integer); + lightmapnumber = 0; + lightmapsize = bound(256, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d); totallightmapsamples = 0; totalverts = 0; @@ -2418,7 +2375,7 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) if (i == -1) { surface->lightmapinfo->samples = NULL; -#if 0 +#if 1 // give non-lightmapped water a 1x white lightmap if (surface->texture->name[0] == '*' && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256) { @@ -2462,20 +2419,20 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) // 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; @@ -2490,18 +2447,21 @@ static void Mod_Q1BSP_LoadFaces(lump_t *l) 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) loadmodel->texturepool = R_AllocTexturePool(); // could not find room, make a new lightmap - lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + loadmodel->brushq3.num_mergedlightmaps = lightmapnumber + 1; + loadmodel->brushq3.data_lightmaps = Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_lightmaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_lightmaps[0])); + loadmodel->brushq3.data_deluxemaps = Mem_Realloc(loadmodel->mempool, loadmodel->brushq3.data_deluxemaps, loadmodel->brushq3.num_mergedlightmaps * sizeof(loadmodel->brushq3.data_deluxemaps[0])); + loadmodel->brushq3.data_lightmaps[lightmapnumber] = lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, NULL); if (loadmodel->brushq1.nmaplightdata) - deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL); + loadmodel->brushq3.data_deluxemaps[lightmapnumber] = deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_ALLOWUPDATES, 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; @@ -2981,26 +2941,7 @@ typedef struct portal_s } 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) { @@ -3023,8 +2964,8 @@ 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; @@ -3033,16 +2974,21 @@ static void Mod_Q1BSP_FinalizePortals(void) // leafs (because qbsp is very sloppy) leaf = loadmodel->brush.data_leafs; endleaf = leaf + loadmodel->brush.num_leafs; - for (;leaf < endleaf;leaf++) + if (mod_recalculatenodeboxes.integer) { - VectorSet(leaf->mins, 2000000000, 2000000000, 2000000000); - VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000); + for (;leaf < endleaf;leaf++) + { + 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) @@ -3050,7 +2996,6 @@ static void Mod_Q1BSP_FinalizePortals(void) 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; @@ -3062,12 +3007,11 @@ static void Mod_Q1BSP_FinalizePortals(void) // 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 @@ -3121,25 +3065,27 @@ static void Mod_Q1BSP_FinalizePortals(void) portal++; } // add the portal's polygon points to the leaf bounding boxes - for (i = 0;i < 2;i++) + if (mod_recalculatenodeboxes.integer) { - leaf = (mleaf_t *)p->nodes[i]; - for (j = 0;j < p->numpoints;j++) + for (i = 0;i < 2;i++) { - 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]; + leaf = (mleaf_t *)p->nodes[i]; + for (j = 0;j < p->numpoints;j++) + { + 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]; + } } } } - 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); + if (mod_recalculatenodeboxes.integer) + Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); } /* @@ -3216,6 +3162,9 @@ static void RemovePortalFromNodes(portal_t *portal) } #define PORTAL_DIST_EPSILON (1.0 / 32.0) +static double *portalpointsbuffer; +static int portalpointsbufferoffset; +static int portalpointsbuffersize; static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) { int i, side; @@ -3223,12 +3172,23 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) mplane_t clipplane, *plane; portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp; int numfrontpoints, numbackpoints; - double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS]; + double *frontpoints, *backpoints; // if a leaf, we're done if (!node->plane) return; + // get some space for our clipping operations to use + if (portalpointsbuffersize < portalpointsbufferoffset + 6*MAX_PORTALPOINTS) + { + portalpointsbuffersize = portalpointsbufferoffset * 2; + portalpointsbuffer = Mem_Realloc(loadmodel->mempool, portalpointsbuffer, portalpointsbuffersize * sizeof(*portalpointsbuffer)); + } + frontpoints = portalpointsbuffer + portalpointsbufferoffset; + portalpointsbufferoffset += 3*MAX_PORTALPOINTS; + backpoints = portalpointsbuffer + portalpointsbufferoffset; + portalpointsbufferoffset += 3*MAX_PORTALPOINTS; + plane = node->plane; front = node->children[0]; @@ -3238,7 +3198,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) // 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) @@ -3321,7 +3281,7 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) } // the portal is split - splitportal = AllocPortal(); + splitportal = (portal_t *)Mem_ExpandableArray_AllocRecord(&portalarray); temp = splitportal->chain; *splitportal = *portal; splitportal->chain = temp; @@ -3346,13 +3306,23 @@ static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node) Mod_Q1BSP_RecursiveNodePortals(front); Mod_Q1BSP_RecursiveNodePortals(back); + + portalpointsbufferoffset -= 6*MAX_PORTALPOINTS; } static void Mod_Q1BSP_MakePortals(void) { - portalchain = NULL; + Mem_ExpandableArray_NewArray(&portalarray, loadmodel->mempool, sizeof(portal_t), 1020*1024/sizeof(portal_t)); + portalpointsbufferoffset = 0; + portalpointsbuffersize = 6*MAX_PORTALPOINTS*128; + portalpointsbuffer = Mem_Alloc(loadmodel->mempool, portalpointsbuffersize * sizeof(*portalpointsbuffer)); Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes + loadmodel->brushq1.hulls[0].firstclipnode); + Mem_Free(portalpointsbuffer); + portalpointsbuffer = NULL; + portalpointsbufferoffset = 0; + portalpointsbuffersize = 0; Mod_Q1BSP_FinalizePortals(); + Mem_ExpandableArray_FreeArray(&portalarray); } //Returns PVS data for a given point @@ -3450,7 +3420,6 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) int i, j, k; dheader_t *header; dmodel_t *bm; - mempool_t *mainmempool; float dist, modelyawradius, modelradius; msurface_t *surface; int numshadowmeshtriangles; @@ -3524,6 +3493,7 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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; @@ -3537,12 +3507,15 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->brush.qw_md4sum2 = 0; for (i = 0;i < HEADER_LUMPS;i++) { + int temp; if (i == LUMP_ENTITIES) continue; - mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen)); + temp = Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen); + mod->brush.qw_md4sum ^= LittleLong(temp); if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES) continue; - mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen)); + temp = Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen); + mod->brush.qw_md4sum2 ^= LittleLong(temp); } Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]); @@ -3576,8 +3549,6 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->numframes = 2; // regular and alternate animation mod->numskins = 1; - mainmempool = mod->mempool; - // make a single combined shadow mesh to allow optimized shadow volume creation numshadowmeshtriangles = 0; for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) @@ -3715,7 +3686,7 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) mod->DrawSky = R_Q1BSP_DrawSky; for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++) - if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)) + if (surface->texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) break; if (j < mod->nummodelsurfaces) mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; @@ -3764,14 +3735,25 @@ void Mod_Q1BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name); } //mod->brushq1.num_visleafs = bm->visleafs; - } - Mod_Q1BSP_LoadMapBrushes(); + if (mod_q1bsp_polygoncollisions.integer) + { + Mod_MakeCollisionBIH(mod, true); + // point traces and contents checks still use the bsp tree + mod->TraceLine = Mod_CollisionBIH_TraceLine; + mod->TraceBox = Mod_CollisionBIH_TraceBox; + } - //Mod_Q1BSP_ProcessLightList(); + // generate VBOs and other shared data before cloning submodels + if (i == 0) + { + Mod_BuildVBOs(); + Mod_Q1BSP_LoadMapBrushes(); + //Mod_Q1BSP_ProcessLightList(); + } + } - if (developer.integer >= 10) - Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals); + Con_DPrintf("Stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); } static void Mod_Q2BSP_LoadEntities(lump_t *l) @@ -4245,13 +4227,21 @@ static void Mod_Q3BSP_LoadEntities(lump_t *l) 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)) { @@ -4291,13 +4281,11 @@ static void Mod_Q3BSP_LoadTextures(lump_t *l) strlcpy (out[i].name, in[i].name, sizeof (out[i].name)); out[i].surfaceflags = LittleLong(in[i].surfaceflags); out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in[i].contents)); + Mod_LoadTextureFromQ3Shader(out + i, out[i].name, true, true, TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); + // restore the surfaceflags and supercontents + out[i].surfaceflags = LittleLong(in[i].surfaceflags); + out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in[i].contents)); } - - if (cls.state == ca_dedicated) - return; - - for (i = 0;i < count;i++, in++, out++) - Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); } static void Mod_Q3BSP_LoadPlanes(lump_t *l) @@ -4431,7 +4419,7 @@ static void Mod_Q3BSP_LoadBrushes(lump_t *l) q3surfaceflags |= planes[j].q3surfaceflags; } // make the colbrush from the planes - out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, q3surfaceflags, out->texture); + out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents, q3surfaceflags, out->texture, true); // this whole loop can take a while (e.g. on redstarrepublic4) CL_KeepaliveMessage(false); @@ -4514,8 +4502,16 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) if (l->filelen % sizeof(int[3])) Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name); count = l->filelen / sizeof(*in); - out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); + if(!loadmodel->brushq3.num_vertices) + { + if (count) + Con_Printf("Mod_Q3BSP_LoadTriangles: %s has triangles but no vertexes, broken compiler, ignoring problem\n", loadmodel->name); + loadmodel->brushq3.num_triangles = 0; + return; + } + + out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out)); loadmodel->brushq3.num_triangles = count / 3; loadmodel->brushq3.data_element3i = out; @@ -4525,8 +4521,6 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) if (*out < 0 || *out >= loadmodel->brushq3.num_vertices) { Con_Printf("Mod_Q3BSP_LoadTriangles: invalid vertexindex %i (%i vertices), setting to 0\n", *out, loadmodel->brushq3.num_vertices); - if(!loadmodel->brushq3.num_vertices) - Host_Error("Mod_Q1BSP_LoadTrianglles: %s has triangles but no vertexes, cannot fix\n", loadmodel->name); *out = 0; } } @@ -4535,7 +4529,7 @@ static void Mod_Q3BSP_LoadTriangles(lump_t *l) static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { q3dlightmap_t *input_pointer; - int i, j, k, count, power, power2, mask, endlightmap, mergewidth, mergeheight; + int i, j, k, count, power, power2, endlightmap, mergewidth, mergeheight; unsigned char *c; unsigned char *convertedpixels; @@ -4579,7 +4573,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) if (developer_loading.integer) Con_Printf("Using external lightmaps\n"); FS_StripExtension(loadmodel->name, mapname, sizeof(mapname)); - inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false); + inpixels[0] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, 0), false, false, false); if(!inpixels[0]) return; @@ -4599,14 +4593,15 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) for(count = 1; ; ++count) { - inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false); + inpixels[count] = loadimagepixelsbgra(va("%s/lm_%04d", mapname, count), false, false, false); if(!inpixels[count]) break; // we got all of them if(image_width != size || image_height != size) { - for(i = 0; i <= count; ++i) - Mem_Free(inpixels[i]); - Host_Error("Mod_Q3BSP_LoadLightmaps: invalid external lightmap size in %s",loadmodel->name); + Mem_Free(inpixels[count]); + inpixels[count] = NULL; + Con_Printf("Mod_Q3BSP_LoadLightmaps: mismatched lightmap size in %s - external lightmap %s/lm_%04d does not match earlier ones\n", loadmodel->name, mapname, count); + break; } } } @@ -4687,7 +4682,7 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) ; // 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; @@ -4703,7 +4698,6 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) power = loadmodel->brushq3.num_lightmapmergepower; power2 = power * 2; - mask = (1 << power) - 1; for (i = 0;i < count;i++) { // figure out which merged lightmap texture this fits into @@ -4733,9 +4727,9 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) ; if (developer_loading.integer) Con_Printf("lightmap merge texture #%i is %ix%i (%i of %i used)\n", lightmapindex, mergewidth*size, mergeheight*size, min(j, mergewidth*mergeheight), mergewidth*mergeheight); - loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + loadmodel->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES), NULL); if (loadmodel->brushq3.data_deluxemaps) - loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), mergewidth * size, mergeheight * size, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : TEXF_ALLOWUPDATES), NULL); } mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / size; @@ -4749,9 +4743,9 @@ static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump) { // figure out which merged lightmap texture this fits into if (loadmodel->brushq3.deluxemapping && (i & 1)) - loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); + loadmodel->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bspdeluxemaps.integer ? TEXF_COMPRESS : 0), NULL); else - loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); + loadmodel->brushq3.data_lightmaps [lightmapindex] = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", lightmapindex), size, size, convertedpixels, TEXTYPE_BGRA, TEXF_FORCELINEAR | (gl_texturecompression_q3bsplightmaps.integer ? TEXF_COMPRESS : 0), NULL); } } @@ -4768,9 +4762,9 @@ static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const int j, k, cnt, tri; float *mins, *maxs; const float *vert; + *collisionstride = stride; if(stride > 0) { - *collisionstride = stride; cnt = (num_triangles + stride - 1) / stride; *collisionbbox6f = (float *) Mem_Alloc(loadmodel->mempool, sizeof(float[6]) * cnt); for(j = 0; j < cnt; ++j) @@ -4807,10 +4801,7 @@ static void Mod_Q3BSP_BuildBBoxes(const int *element3i, int num_triangles, const } } else - { - *collisionstride = 0; *collisionbbox6f = NULL; - } } typedef struct patchtess_s @@ -4837,7 +4828,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) { 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, meshvertices, meshtriangles, numvertices, numtriangles, cxtess, cytess; + int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, collisionvertices, collisiontriangles, numvertices, numtriangles, cxtess, cytess; float lightmaptcbase[2], lightmaptcscale[2]; //int *originalelement3i; //int *originalneighbor3i; @@ -4848,6 +4839,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) float *originalcolor4f; float *originaltexcoordtexture2f; float *originaltexcoordlightmap2f; + float *surfacecollisionvertex3f; + int *surfacecollisionelement3i; float *v; patchtess_t *patchtess = NULL; int patchtesscount = 0; @@ -4894,8 +4887,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) n = LittleLong(in->effectindex); if (n < -1 || n >= loadmodel->brushq3.num_effects) { - if (developer.integer >= 100) - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects); + if (developer_extra.integer) + Con_DPrintf("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) @@ -4989,18 +4982,18 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) patchtess[patchtesscount].info.lods[PATCH_LOD_COLLISION].ytess = cytess; patchtess[patchtesscount].surface_id = i; - patchtess[patchtesscount].lodgroup[0] = in->specific.patch.mins[0]; - patchtess[patchtesscount].lodgroup[1] = in->specific.patch.mins[1]; - patchtess[patchtesscount].lodgroup[2] = in->specific.patch.mins[2]; - patchtess[patchtesscount].lodgroup[3] = in->specific.patch.maxs[0]; - patchtess[patchtesscount].lodgroup[4] = in->specific.patch.maxs[1]; - patchtess[patchtesscount].lodgroup[5] = in->specific.patch.maxs[2]; + patchtess[patchtesscount].lodgroup[0] = LittleFloat(in->specific.patch.mins[0]); + patchtess[patchtesscount].lodgroup[1] = LittleFloat(in->specific.patch.mins[1]); + patchtess[patchtesscount].lodgroup[2] = LittleFloat(in->specific.patch.mins[2]); + patchtess[patchtesscount].lodgroup[3] = LittleFloat(in->specific.patch.maxs[0]); + patchtess[patchtesscount].lodgroup[4] = LittleFloat(in->specific.patch.maxs[1]); + patchtess[patchtesscount].lodgroup[5] = LittleFloat(in->specific.patch.maxs[2]); patchtess[patchtesscount].originalvertex3f = originalvertex3f; ++patchtesscount; break; case Q3FACETYPE_FLARE: - if (developer.integer >= 100) - Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name); + if (developer_extra.integer) + Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name); // don't render it continue; } @@ -5029,6 +5022,8 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) while (again); // Calculate resulting number of triangles + collisionvertices = 0; + collisiontriangles = 0; for(i = 0; i < patchtesscount; ++i) { finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_VISUAL].xtess); @@ -5040,14 +5035,31 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) oldout[patchtess[i].surface_id].num_triangles = numtriangles; meshvertices += oldout[patchtess[i].surface_id].num_vertices; meshtriangles += oldout[patchtess[i].surface_id].num_triangles; + + finalwidth = Q3PatchDimForTess(patchtess[i].info.xsize, patchtess[i].info.lods[PATCH_LOD_COLLISION].xtess); + finalheight = Q3PatchDimForTess(patchtess[i].info.ysize,patchtess[i].info.lods[PATCH_LOD_COLLISION].ytess); + numvertices = finalwidth * finalheight; + numtriangles = (finalwidth - 1) * (finalheight - 1) * 2; + + oldout[patchtess[i].surface_id].num_collisionvertices = numvertices; + oldout[patchtess[i].surface_id].num_collisiontriangles = numtriangles; + collisionvertices += oldout[patchtess[i].surface_id].num_collisionvertices; + collisiontriangles += oldout[patchtess[i].surface_id].num_collisiontriangles; } i = oldi; in = oldin; out = oldout; Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false); + if (collisiontriangles) + { + loadmodel->brush.data_collisionvertex3f = Mem_Alloc(loadmodel->mempool, collisionvertices * sizeof(float[3])); + loadmodel->brush.data_collisionelement3i = Mem_Alloc(loadmodel->mempool, collisiontriangles * sizeof(int[3])); + } meshvertices = 0; meshtriangles = 0; + collisionvertices = 0; + collisiontriangles = 0; for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++) { if (out->num_vertices < 3 || out->num_triangles < 1) @@ -5058,6 +5070,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) firstelement = LittleLong(in->firstelement); out->num_firstvertex = meshvertices; out->num_firsttriangle = meshtriangles; + out->num_firstcollisiontriangle = collisiontriangles; switch(type) { case Q3FACETYPE_FLAT: @@ -5111,7 +5124,7 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) finalwidth = Q3PatchDimForTess(patchsize[0],xtess); //((patchsize[0] - 1) * xtess) + 1; finalheight = Q3PatchDimForTess(patchsize[1],ytess); //((patchsize[1] - 1) * ytess) + 1; finalvertices = finalwidth * finalheight; - finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; + oldnumtriangles = finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; type = Q3FACETYPE_MESH; // generate geometry // (note: normals are skipped because they get recalculated) @@ -5124,40 +5137,62 @@ static void Mod_Q3BSP_LoadFaces(lump_t *l) out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f); - if (developer.integer >= 100) + if (developer_extra.integer) { 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); + Con_DPrintf("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_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles); } // q3map does not put in collision brushes for curves... ugh // build the lower quality collision geometry finalwidth = Q3PatchDimForTess(patchsize[0],cxtess); //((patchsize[0] - 1) * cxtess) + 1; finalheight = Q3PatchDimForTess(patchsize[1],cytess); //((patchsize[1] - 1) * cytess) + 1; finalvertices = finalwidth * finalheight; - finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; + oldnumtriangles2 = finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2; - out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices); - out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles); + // legacy collision geometry implementation + out->deprecatedq3data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices); + out->deprecatedq3data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles); out->num_collisionvertices = finalvertices; out->num_collisiontriangles = finaltriangles; - Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); - Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0); + Q3PatchTesselateFloat(3, sizeof(float[3]), out->deprecatedq3data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); + Q3PatchTriangleElements(out->deprecatedq3data_collisionelement3i, finalwidth, finalheight, 0); //Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25); - Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1); + Mod_SnapVertices(3, finalvertices, out->deprecatedq3data_collisionvertex3f, 1); - oldnumtriangles = out->num_triangles; - oldnumtriangles2 = out->num_collisiontriangles; - out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f); + out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(finaltriangles, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_collisionelement3i, out->deprecatedq3data_collisionvertex3f); // now optimize the collision mesh by finding triangle bboxes... - Mod_Q3BSP_BuildBBoxes(out->data_collisionelement3i, out->num_collisiontriangles, out->data_collisionvertex3f, &out->data_collisionbbox6f, &out->num_collisionbboxstride, mod_q3bsp_curves_collisions_stride.integer); - Mod_Q3BSP_BuildBBoxes(loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle, out->num_triangles, loadmodel->surfmesh.data_vertex3f, &out->data_bbox6f, &out->num_bboxstride, mod_q3bsp_curves_stride.integer); + Mod_Q3BSP_BuildBBoxes(out->deprecatedq3data_collisionelement3i, out->num_collisiontriangles, out->deprecatedq3data_collisionvertex3f, &out->deprecatedq3data_collisionbbox6f, &out->deprecatedq3num_collisionbboxstride, mod_q3bsp_curves_collisions_stride.integer); + Mod_Q3BSP_BuildBBoxes(loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle, out->num_triangles, loadmodel->surfmesh.data_vertex3f, &out->deprecatedq3data_bbox6f, &out->deprecatedq3num_bboxstride, mod_q3bsp_curves_stride.integer); + + // store collision geometry for BIH collision tree + surfacecollisionvertex3f = loadmodel->brush.data_collisionvertex3f + collisionvertices * 3; + surfacecollisionelement3i = loadmodel->brush.data_collisionelement3i + collisiontriangles * 3; + Q3PatchTesselateFloat(3, sizeof(float[3]), surfacecollisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, cxtess, cytess); + Q3PatchTriangleElements(surfacecollisionelement3i, finalwidth, finalheight, collisionvertices); + Mod_SnapVertices(3, finalvertices, surfacecollisionvertex3f, 1); +#if 1 + // remove this once the legacy code is removed + { + int nc = out->num_collisiontriangles; +#endif + out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(finaltriangles, surfacecollisionelement3i, surfacecollisionelement3i, loadmodel->brush.data_collisionvertex3f); +#if 1 + if(nc != out->num_collisiontriangles) + { + Con_Printf("number of collision triangles differs between BIH and BSP. FAIL.\n"); + } + } +#endif + + if (developer_extra.integer) + Con_DPrintf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles); - if (developer.integer >= 100) - Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles); + collisionvertices += finalvertices; + collisiontriangles += out->num_collisiontriangles; break; default: break; @@ -5472,7 +5507,10 @@ static void Mod_Q3BSP_LoadLightGrid(lump_t *l) 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)); @@ -5652,7 +5690,7 @@ static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t s 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 @@ -5664,131 +5702,676 @@ static qboolean Mod_Q3BSP_TraceLineOfSight(struct model_s *model, const vec3_t s } } -static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_model_t *model, mnode_t *node, const vec3_t point, int markframe) +static void Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t point) { - int i; - mleaf_t *leaf; - colbrushf_t *brush; - // find which leaf the point is in - while (node->plane) - node = node->children[(node->plane->type < 3 ? point[node->plane->type] : DotProduct(point, node->plane->normal)) < node->plane->dist]; - // point trace the brushes - leaf = (mleaf_t *)node; - for (i = 0;i < leaf->numleafbrushes;i++) + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + int axis; + while (nodenum >= 0) { - brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf; - if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs)) + node = model->collision_bih.nodes + nodenum; + axis = node->type - BIH_SPLITX; + if (point[axis] <= node->backmax) { - brush->markframe = markframe; - Collision_TracePointBrushFloat(trace, point, brush); + if (point[axis] >= node->frontmin) + Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, node->front, point); + nodenum = node->back; } + else if (point[axis] >= node->frontmin) + nodenum = node->front; + else // no overlap with either child? just return + return; + } + if (!model->collision_bih.leafs) + return; + leaf = model->collision_bih.leafs + (-1-nodenum); + switch(leaf->type) + { + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TracePointBrushFloat(trace, point, brush); + break; + case BIH_COLLISIONTRIANGLE: + // collision triangle - skipped because they have no volume + break; + case BIH_RENDERTRIANGLE: + // render triangle - skipped because they have no volume + break; } - // can't do point traces on curves (they have no thickness) } -static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, dp_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], nodesegmentmins[3], nodesegmentmaxs[3]; - mleaf_t *leaf; - msurface_t *surface; - mplane_t *plane; - colbrushf_t *brush; - // walk the tree until we hit a leaf, recursing for any split cases - while (node->plane) - { - // abort if this part of the bsp tree can not be hit by this trace -// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) -// return; - plane = node->plane; - // axial planes are much more common than non-axial, so an optimized - // axial case pays off here - if (plane->type < 3) +static void Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const vec3_t start, const vec3_t end, const vec3_t linestart, const vec3_t lineend) +{ + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + const int *e; + const texture_t *texture; + int axis; +#define BIHLINECLIP +#ifdef BIHLINECLIP + int sideflags; + vec_t frontdist1; + vec_t frontdist2; + vec_t frontfrac; + vec_t backdist1; + vec_t backdist2; + vec_t backfrac; + vec3_t clipped[2]; +#endif + vec3_t segmentmins; + vec3_t segmentmaxs; + 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]); + while (nodenum >= 0) + { + node = model->collision_bih.nodes + nodenum; +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; +#endif + axis = node->type - BIH_SPLITX; +#if 0 + if (segmentmins[axis] <= node->backmax) { - dist1 = start[plane->type] - plane->dist; - dist2 = end[plane->type] - plane->dist; + if (segmentmaxs[axis] >= node->frontmin) + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); + nodenum = node->back; } + else if (segmentmaxs[axis] >= node->frontmin) + nodenum = node->front; else + return; // trace falls between children +#else + frontdist1 = start[axis] - node->frontmin; + frontdist2 = end[axis] - node->frontmin; + backdist1 = start[axis] - node->backmax; + backdist2 = end[axis] - node->backmax; + sideflags = 0; + if (frontdist1 < 0) + sideflags |= 1; + if (frontdist2 < 0) + sideflags |= 2; + if (backdist1 < 0) + sideflags |= 4; + if (backdist2 < 0) + sideflags |= 8; +#if 0 + if (sideflags & 12) { - dist1 = DotProduct(start, plane->normal) - plane->dist; - dist2 = DotProduct(end, plane->normal) - plane->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]; + if ((sideflags & 3) != 3) + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); + nodenum = node->back; } + else if ((sideflags & 3) != 3) + nodenum = node->front; else + return; // trace falls between children +#else + switch(sideflags) { - // line crosses node plane, split the line - dist1 = PlaneDiff(linestart, plane); - dist2 = PlaneDiff(lineend, plane); - midfrac = dist1 / (dist1 - dist2); - VectorLerp(linestart, midfrac, lineend, 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 we found an impact on the front side, don't waste time - // exploring the far side - if (midfrac <= trace->realfraction) - Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); - return; - } - } - // abort if this part of the bsp tree can not be hit by this trace -// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) -// return; - // hit a leaf - nodesegmentmins[0] = min(start[0], end[0]) - 1; - nodesegmentmins[1] = min(start[1], end[1]) - 1; - nodesegmentmins[2] = min(start[2], end[2]) - 1; - nodesegmentmaxs[0] = max(start[0], end[0]) + 1; - nodesegmentmaxs[1] = max(start[1], end[1]) + 1; - nodesegmentmaxs[2] = max(start[2], end[2]) + 1; - // line 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(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs)) - { - brush->markframe = markframe; - Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush); + case 0: + // start end START END + nodenum = node->front; + continue; + case 1: + // START end START END +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[0]); + start = clipped[0]; + 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]); +#endif + nodenum = node->front; + break; + case 2: +#ifdef BIHLINECLIP + // start END START END + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[0]); + end = clipped[0]; + 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]); +#endif + nodenum = node->front; + break; + case 3: + // START END START END + return; // line falls in gap between children + case 4: + // start end start END + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#ifdef BIHLINECLIP + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + end = clipped[0]; + 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]); +#endif + nodenum = node->back; + break; + case 5: + // START end start END +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend); + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + end = clipped[0]; + 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]); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 6: + // start END start END +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend); + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + end = clipped[0]; + 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]); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 7: + // START END start END +#ifdef BIHLINECLIP + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + end = clipped[0]; + 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]); +#endif + nodenum = node->back; + break; + case 8: + // start end START end + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#ifdef BIHLINECLIP + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + start = clipped[0]; + 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]); +#endif + nodenum = node->back; + break; + case 9: + // START end START end +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend); + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + start = clipped[0]; + 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]); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 10: + // start END START end +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend); + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + start = clipped[0]; + 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]); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 11: + // START END START end +#ifdef BIHLINECLIP + backfrac = backdist1 / (backdist1 - backdist2); + VectorLerp(start, backfrac, end, clipped[0]); + start = clipped[0]; + 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]); +#endif + nodenum = node->back; + break; + case 12: + // start end start end + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); + nodenum = node->back; + break; + case 13: + // START end start end +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, clipped[1], end, linestart, lineend); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 14: + // start END start end +#ifdef BIHLINECLIP + frontfrac = frontdist1 / (frontdist1 - frontdist2); + VectorLerp(start, frontfrac, end, clipped[1]); + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, clipped[1], linestart, lineend); +#else + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, node->front, start, end, linestart, lineend); +#endif + nodenum = node->back; + break; + case 15: + // START END start end + nodenum = node->back; + continue; } +#endif +#endif } - // can't do point traces on curves (they have no thickness) - if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end)) + if (!model->collision_bih.leafs) + return; + leaf = model->collision_bih.leafs + (-1-nodenum); +#if 1 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif + switch(leaf->type) { - // line trace the curves - for (i = 0;i < leaf->numleafsurfaces;i++) - { - surface = model->data_surfaces + leaf->firstleafsurface[i]; - if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) - { - surface->collisionmarkframe = markframe; - Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); - } - } + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush); + break; + case BIH_COLLISIONTRIANGLE: + if (!mod_q3bsp_curves_collisions.integer) + return; + e = model->brush.data_collisionelement3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceLineTriangleFloat(trace, linestart, lineend, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + case BIH_RENDERTRIANGLE: + e = model->surfmesh.data_element3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceLineTriangleFloat(trace, linestart, lineend, model->surfmesh.data_vertex3f + e[0] * 3, model->surfmesh.data_vertex3f + e[1] * 3, model->surfmesh.data_vertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; } } -static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_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) +static void Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace_t *trace, dp_model_t *model, int nodenum, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, const vec3_t segmentmins, const vec3_t segmentmaxs) { - int i; - int sides; - mleaf_t *leaf; - colbrushf_t *brush; - msurface_t *surface; - mplane_t *plane; - float nodesegmentmins[3], nodesegmentmaxs[3]; - // walk the tree until we hit a leaf, recursing for any split cases - while (node->plane) + const bih_leaf_t *leaf; + const bih_node_t *node; + const colbrushf_t *brush; + const int *e; + const texture_t *texture; + int axis; + while (nodenum >= 0) { - // abort if this part of the bsp tree can not be hit by this trace -// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) -// return; - plane = node->plane; + node = model->collision_bih.nodes + nodenum; + axis = node->type - BIH_SPLITX; +#if 1 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; +#endif +#if 0 + Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs); + nodenum = node->back; + continue; +#endif + if (segmentmins[axis] <= node->backmax) + { + if (segmentmaxs[axis] >= node->frontmin) + Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, node->front, thisbrush_start, thisbrush_end, segmentmins, segmentmaxs); + nodenum = node->back; + } + else if (segmentmaxs[axis] >= node->frontmin) + nodenum = node->front; + else + return; // trace falls between children + } + if (!model->collision_bih.leafs) + return; + leaf = model->collision_bih.leafs + (-1-nodenum); +#if 1 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif + switch(leaf->type) + { + case BIH_BRUSH: + brush = model->brush.data_brushes[leaf->itemindex].colbrushf; + Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush); + break; + case BIH_COLLISIONTRIANGLE: + if (!mod_q3bsp_curves_collisions.integer) + return; + e = model->brush.data_collisionelement3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceBrushTriangleFloat(trace, thisbrush_start, thisbrush_end, model->brush.data_collisionvertex3f + e[0] * 3, model->brush.data_collisionvertex3f + e[1] * 3, model->brush.data_collisionvertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + case BIH_RENDERTRIANGLE: + e = model->surfmesh.data_element3i + 3*leaf->itemindex; + texture = model->data_textures + leaf->textureindex; + Collision_TraceBrushTriangleFloat(trace, thisbrush_start, thisbrush_end, model->surfmesh.data_vertex3f + e[0] * 3, model->surfmesh.data_vertex3f + e[1] * 3, model->surfmesh.data_vertex3f + e[2] * 3, texture->supercontents, texture->surfaceflags, texture); + break; + } +} + +void Mod_CollisionBIH_TracePoint(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +{ + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start); +} + +void Mod_CollisionBIH_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) +{ + if (VectorCompare(start, end)) + { + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); + return; + } + + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end); +} + +void Mod_CollisionBIH_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) +{ + float segmentmins[3], segmentmaxs[3]; + colboxbrushf_t thisbrush_start, thisbrush_end; + vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; + + if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs)) + { + vec3_t shiftstart, shiftend; + VectorAdd(start, boxmins, shiftstart); + VectorAdd(end, boxmins, shiftend); + if (VectorCompare(start, end)) + Mod_CollisionBIH_TracePoint(model, frameblend, skeleton, trace, shiftstart, hitsupercontentsmask); + else + { + Mod_CollisionBIH_TraceLine(model, frameblend, skeleton, trace, shiftstart, shiftend, hitsupercontentsmask); + VectorSubtract(trace->endpos, boxmins, trace->endpos); + } + return; + } + + // box trace, performed as brush trace + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1; + segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1; + segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1; + segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1; + segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1; + segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1; + VectorAdd(start, boxmins, boxstartmins); + VectorAdd(start, boxmaxs, boxstartmaxs); + VectorAdd(end, boxmins, boxendmins); + VectorAdd(end, boxmaxs, boxendmaxs); + Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL); + Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL); + Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, &thisbrush_start.brush, &thisbrush_end.brush, segmentmins, segmentmaxs); +} + +int Mod_CollisionBIH_PointSuperContents(struct model_s *model, int frame, const vec3_t point) +{ + trace_t trace; + Mod_CollisionBIH_TracePoint(model, NULL, NULL, &trace, point, 0); + return trace.startsupercontents; +} + +void Mod_CollisionBIH_TracePoint_Mesh(dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, trace_t *trace, const vec3_t start, int hitsupercontentsmask) +{ +#if 0 + // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid + vec3_t end; + int hitsupercontents; + VectorSet(end, start[0], start[1], model->normalmins[2]); +#endif + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; +#if 0 + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end); + hitsupercontents = trace->hitsupercontents; + memset(trace, 0, sizeof(*trace)); + trace->fraction = 1; + trace->realfraction = 1; + trace->hitsupercontentsmask = hitsupercontentsmask; + trace->startsupercontents = hitsupercontents; +#endif +} + +int Mod_CollisionBIH_PointSuperContents_Mesh(struct model_s *model, int frame, const vec3_t start) +{ +#if 0 + // broken - needs to be modified to count front faces and backfaces to figure out if it is in solid + trace_t trace; + vec3_t end; + VectorSet(end, start[0], start[1], model->normalmins[2]); + memset(&trace, 0, sizeof(trace)); + trace.fraction = 1; + trace.realfraction = 1; + trace.hitsupercontentsmask = 0; + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(&trace, model, model->collision_bih.rootnode, start, end, start, end); + return trace.hitsupercontents; +#else + return 0; +#endif +} + +static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, dp_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[(node->plane->type < 3 ? point[node->plane->type] : 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, dp_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], nodesegmentmins[3], nodesegmentmaxs[3]; + mleaf_t *leaf; + msurface_t *surface; + mplane_t *plane; + colbrushf_t *brush; + // walk the tree until we hit a leaf, recursing for any split cases + while (node->plane) + { +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; + Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[0], start, end, startfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); + node = node->children[1]; +#else + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; + plane = node->plane; + // axial planes are much more common than non-axial, so an optimized + // axial case pays off here + if (plane->type < 3) + { + dist1 = start[plane->type] - plane->dist; + dist2 = end[plane->type] - plane->dist; + } + else + { + dist1 = DotProduct(start, plane->normal) - plane->dist; + dist2 = DotProduct(end, plane->normal) - plane->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 + dist1 = PlaneDiff(linestart, plane); + dist2 = PlaneDiff(lineend, plane); + midfrac = dist1 / (dist1 - dist2); + VectorLerp(linestart, midfrac, lineend, 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 we found an impact on the front side, don't waste time + // exploring the far side + if (midfrac <= trace->realfraction) + Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs); + return; + } +#endif + } + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; + // hit a leaf + nodesegmentmins[0] = min(start[0], end[0]) - 1; + nodesegmentmins[1] = min(start[1], end[1]) - 1; + nodesegmentmins[2] = min(start[2], end[2]) - 1; + nodesegmentmaxs[0] = max(start[0], end[0]) + 1; + nodesegmentmaxs[1] = max(start[1], end[1]) + 1; + nodesegmentmaxs[2] = max(start[2], end[2]) + 1; + // line trace the brushes + leaf = (mleaf_t *)node; +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif + 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_TraceLineBrushFloat(trace, linestart, lineend, brush, brush); + } + } + // can't do point traces on curves (they have no thickness) + if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end)) + { + // line trace the curves + for (i = 0;i < leaf->numleafsurfaces;i++) + { + surface = model->data_surfaces + leaf->firstleafsurface[i]; + if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) + { + surface->deprecatedq3collisionmarkframe = markframe; + Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + } + } + } +} + +static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_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; + int sides; + mleaf_t *leaf; + colbrushf_t *brush; + msurface_t *surface; + mplane_t *plane; + float nodesegmentmins[3], nodesegmentmaxs[3]; + // walk the tree until we hit a leaf, recursing for any split cases + while (node->plane) + { +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, node->mins, node->maxs)) + return; + Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs); + node = node->children[1]; +#else + // abort if this part of the bsp tree can not be hit by this trace +// if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) +// return; + plane = node->plane; // axial planes are much more common than non-axial, so an optimized // axial case pays off here if (plane->type < 3) @@ -5819,6 +6402,7 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo return; // ERROR: NAN bounding box! // take whichever side the segment box is on node = node->children[sides - 1]; +#endif } // abort if this part of the bsp tree can not be hit by this trace // if (!(node->combinedsupercontents & trace->hitsupercontentsmask)) @@ -5831,6 +6415,10 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2] + 1); // hit a leaf leaf = (mleaf_t *)node; +#if 0 + if (!BoxesOverlap(segmentmins, segmentmaxs, leaf->mins, leaf->maxs)) + return; +#endif for (i = 0;i < leaf->numleafbrushes;i++) { brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf; @@ -5845,18 +6433,19 @@ static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, dp_model_t *mo for (i = 0;i < leaf->numleafsurfaces;i++) { surface = model->data_surfaces + leaf->firstleafsurface[i]; - if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) + if (surface->num_collisiontriangles && surface->deprecatedq3collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs)) { - surface->collisionmarkframe = markframe; - Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + surface->deprecatedq3collisionmarkframe = markframe; + Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } } } } + 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; @@ -5864,7 +6453,9 @@ static void Mod_Q3BSP_TracePoint(dp_model_t *model, int frame, trace_t *trace, c trace->fraction = 1; trace->realfraction = 1; trace->hitsupercontentsmask = hitsupercontentsmask; - if (model->brush.submodel) + if (mod_collision_bih.integer) + Mod_CollisionBIH_TracePoint_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start); + else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) if (brush->colbrushf) @@ -5874,7 +6465,7 @@ static void Mod_Q3BSP_TracePoint(dp_model_t *model, int frame, trace_t *trace, c 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]; @@ -5883,7 +6474,7 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, int frame, trace_t *trace, co if (VectorCompare(start, end)) { - Mod_Q3BSP_TracePoint(model, frame, trace, start, hitsupercontentsmask); + Mod_Q3BSP_TracePoint(model, frameblend, skeleton, trace, start, hitsupercontentsmask); return; } @@ -5897,27 +6488,29 @@ static void Mod_Q3BSP_TraceLine(dp_model_t *model, int frame, trace_t *trace, co segmentmaxs[0] = max(start[0], end[0]) + 1; segmentmaxs[1] = max(start[1], end[1]) + 1; segmentmaxs[2] = max(start[2], end[2]) + 1; - if (model->brush.submodel) + if (mod_collision_bih.integer) + Mod_CollisionBIH_TraceLine_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, start, end, start, end); + else if (model->brush.submodel) { for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) - if (brush->colbrushf) + if (brush->colbrushf && BoxesOverlap(segmentmins, segmentmaxs, brush->colbrushf->mins, brush->colbrushf->maxs)) Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf); if (mod_q3bsp_curves_collisions.integer) for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) - if (surface->num_collisiontriangles) - Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + if (surface->num_collisiontriangles && BoxesOverlap(segmentmins, segmentmaxs, surface->mins, surface->maxs)) + Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } else 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]; msurface_t *surface; q3mbrush_t *brush; - colbrushf_t *thisbrush_start, *thisbrush_end; + colboxbrushf_t thisbrush_start, thisbrush_end; vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs; if (mod_q3bsp_optimizedtraceline.integer && VectorCompare(boxmins, boxmaxs)) @@ -5926,10 +6519,10 @@ static void Mod_Q3BSP_TraceBox(dp_model_t *model, int frame, trace_t *trace, con 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; @@ -5950,20 +6543,22 @@ static void Mod_Q3BSP_TraceBox(dp_model_t *model, int frame, trace_t *trace, con VectorAdd(start, boxmaxs, boxstartmaxs); VectorAdd(end, boxmins, boxendmins); VectorAdd(end, boxmaxs, boxendmaxs); - thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL); - thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL); - if (model->brush.submodel) + Collision_BrushForBox(&thisbrush_start, boxstartmins, boxstartmaxs, 0, 0, NULL); + Collision_BrushForBox(&thisbrush_end, boxendmins, boxendmaxs, 0, 0, NULL); + if (mod_collision_bih.integer) + Mod_CollisionBIH_TraceBrush_RecursiveBIHNode(trace, model, model->collision_bih.rootnode, &thisbrush_start.brush, &thisbrush_end.brush, segmentmins, segmentmaxs); + else if (model->brush.submodel) { 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 (brush->colbrushf && BoxesOverlap(segmentmins, segmentmaxs, brush->colbrushf->mins, brush->colbrushf->maxs)) + Collision_TraceBrushBrushFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, brush->colbrushf, brush->colbrushf); if (mod_q3bsp_curves_collisions.integer) for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++) - if (surface->num_collisiontriangles) - Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->num_collisionbboxstride, surface->data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); + if (surface->num_collisiontriangles && BoxesOverlap(segmentmins, segmentmaxs, surface->mins, surface->maxs)) + Collision_TraceBrushTriangleMeshFloat(trace, &thisbrush_start.brush, &thisbrush_end.brush, surface->num_collisiontriangles, surface->deprecatedq3data_collisionelement3i, surface->deprecatedq3data_collisionvertex3f, surface->deprecatedq3num_collisionbboxstride, surface->deprecatedq3data_collisionbbox6f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs); } else - Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs); + Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, &thisbrush_start.brush, &thisbrush_end.brush, ++markframe, segmentmins, segmentmaxs); } static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const vec3_t point) @@ -5971,8 +6566,14 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const int i; int supercontents = 0; q3mbrush_t *brush; + if (mod_collision_bih.integer) + { + trace_t trace; + Mod_Q3BSP_TracePoint(model, NULL, NULL, &trace, point, 0); + supercontents = trace.startsupercontents; + } // test if the point is inside each brush - if (model->brush.submodel) + else if (model->brush.submodel) { // submodels are effectively one leaf for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++) @@ -5998,17 +6599,147 @@ static int Mod_Q3BSP_PointSuperContents(struct model_s *model, int frame, const return supercontents; } -static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) -{ - int supercontents = 0; - if (nativecontents & CONTENTSQ3_SOLID) - supercontents |= SUPERCONTENTS_SOLID; - if (nativecontents & CONTENTSQ3_WATER) - supercontents |= SUPERCONTENTS_WATER; - if (nativecontents & CONTENTSQ3_SLIME) - supercontents |= SUPERCONTENTS_SLIME; - if (nativecontents & CONTENTSQ3_LAVA) - supercontents |= SUPERCONTENTS_LAVA; +void Mod_MakeCollisionBIH(dp_model_t *model, qboolean userendersurfaces) +{ + int j; + int bihnumleafs; + int bihmaxnodes; + int brushindex; + int triangleindex; + int bihleafindex; + int nummodelbrushes = model->nummodelbrushes; + int nummodelsurfaces = model->nummodelsurfaces; + const int *e; + const int *collisionelement3i; + const float *collisionvertex3f; + const int *renderelement3i; + const float *rendervertex3f; + bih_leaf_t *bihleafs; + bih_node_t *bihnodes; + int *temp_leafsort; + int *temp_leafsortscratch; + const msurface_t *surface; + const q3mbrush_t *brush; + + // find out how many BIH leaf nodes we need + bihnumleafs = 0; + if (userendersurfaces) + { + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + bihnumleafs += surface->num_triangles; + } + else + { + for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++) + if (brush->colbrushf) + bihnumleafs++; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + if (surface->texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS) + bihnumleafs += surface->num_triangles; + else + bihnumleafs += surface->num_collisiontriangles; + } + } + + if (!bihnumleafs) + return; + + // allocate the memory for the BIH leaf nodes + bihleafs = Mem_Alloc(loadmodel->mempool, sizeof(bih_leaf_t) * bihnumleafs); + + // now populate the BIH leaf nodes + bihleafindex = 0; + + // add render surfaces + renderelement3i = model->surfmesh.data_element3i; + rendervertex3f = model->surfmesh.data_vertex3f; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + for (triangleindex = 0, e = renderelement3i + 3*surface->num_firsttriangle;triangleindex < surface->num_triangles;triangleindex++, e += 3) + { + if (!userendersurfaces && !(surface->texture->basematerialflags & MATERIALFLAG_MESHCOLLISIONS)) + continue; + bihleafs[bihleafindex].type = BIH_RENDERTRIANGLE; + bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures; + bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firsttriangle; + bihleafs[bihleafindex].mins[0] = min(rendervertex3f[3*e[0]+0], min(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) - 1; + bihleafs[bihleafindex].mins[1] = min(rendervertex3f[3*e[0]+1], min(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) - 1; + bihleafs[bihleafindex].mins[2] = min(rendervertex3f[3*e[0]+2], min(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) - 1; + bihleafs[bihleafindex].maxs[0] = max(rendervertex3f[3*e[0]+0], max(rendervertex3f[3*e[1]+0], rendervertex3f[3*e[2]+0])) + 1; + bihleafs[bihleafindex].maxs[1] = max(rendervertex3f[3*e[0]+1], max(rendervertex3f[3*e[1]+1], rendervertex3f[3*e[2]+1])) + 1; + bihleafs[bihleafindex].maxs[2] = max(rendervertex3f[3*e[0]+2], max(rendervertex3f[3*e[1]+2], rendervertex3f[3*e[2]+2])) + 1; + bihleafindex++; + } + } + + if (!userendersurfaces) + { + // add collision brushes + for (brushindex = 0, brush = model->brush.data_brushes + brushindex+model->firstmodelbrush;brushindex < nummodelbrushes;brushindex++, brush++) + { + if (!brush->colbrushf) + continue; + bihleafs[bihleafindex].type = BIH_BRUSH; + bihleafs[bihleafindex].textureindex = brush->texture - model->data_textures; + bihleafs[bihleafindex].itemindex = brushindex+model->firstmodelbrush; + VectorCopy(brush->colbrushf->mins, bihleafs[bihleafindex].mins); + VectorCopy(brush->colbrushf->maxs, bihleafs[bihleafindex].maxs); + bihleafindex++; + } + + // add collision surfaces + collisionelement3i = model->brush.data_collisionelement3i; + collisionvertex3f = model->brush.data_collisionvertex3f; + for (j = 0, surface = model->data_surfaces + model->firstmodelsurface;j < nummodelsurfaces;j++, surface++) + { + for (triangleindex = 0, e = collisionelement3i + 3*surface->num_firstcollisiontriangle;triangleindex < surface->num_collisiontriangles;triangleindex++, e += 3) + { + bihleafs[bihleafindex].type = BIH_COLLISIONTRIANGLE; + bihleafs[bihleafindex].textureindex = surface->texture - model->data_textures; + bihleafs[bihleafindex].itemindex = triangleindex+surface->num_firstcollisiontriangle; + bihleafs[bihleafindex].mins[0] = min(collisionvertex3f[3*e[0]+0], min(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) - 1; + bihleafs[bihleafindex].mins[1] = min(collisionvertex3f[3*e[0]+1], min(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) - 1; + bihleafs[bihleafindex].mins[2] = min(collisionvertex3f[3*e[0]+2], min(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) - 1; + bihleafs[bihleafindex].maxs[0] = max(collisionvertex3f[3*e[0]+0], max(collisionvertex3f[3*e[1]+0], collisionvertex3f[3*e[2]+0])) + 1; + bihleafs[bihleafindex].maxs[1] = max(collisionvertex3f[3*e[0]+1], max(collisionvertex3f[3*e[1]+1], collisionvertex3f[3*e[2]+1])) + 1; + bihleafs[bihleafindex].maxs[2] = max(collisionvertex3f[3*e[0]+2], max(collisionvertex3f[3*e[1]+2], collisionvertex3f[3*e[2]+2])) + 1; + bihleafindex++; + } + } + } + + // allocate buffers for the produced and temporary data + bihmaxnodes = bihnumleafs - 1; + bihnodes = Mem_Alloc(loadmodel->mempool, sizeof(bih_node_t) * bihmaxnodes); + temp_leafsort = Mem_Alloc(loadmodel->mempool, sizeof(int) * bihnumleafs * 2); + temp_leafsortscratch = temp_leafsort + bihnumleafs; + + // now build it + BIH_Build(&model->collision_bih, bihnumleafs, bihleafs, bihmaxnodes, bihnodes, temp_leafsort, temp_leafsortscratch); + + // we're done with the temporary data + Mem_Free(temp_leafsort); + + // resize the BIH nodes array if it over-allocated + if (model->collision_bih.maxnodes > model->collision_bih.numnodes) + { + model->collision_bih.maxnodes = model->collision_bih.numnodes; + model->collision_bih.nodes = Mem_Realloc(loadmodel->mempool, model->collision_bih.nodes, model->collision_bih.numnodes * sizeof(bih_node_t)); + } +} + +static int Mod_Q3BSP_SuperContentsFromNativeContents(dp_model_t *model, int nativecontents) +{ + int supercontents = 0; + if (nativecontents & CONTENTSQ3_SOLID) + supercontents |= SUPERCONTENTS_SOLID; + if (nativecontents & CONTENTSQ3_WATER) + supercontents |= SUPERCONTENTS_WATER; + if (nativecontents & CONTENTSQ3_SLIME) + supercontents |= SUPERCONTENTS_SLIME; + if (nativecontents & CONTENTSQ3_LAVA) + supercontents |= SUPERCONTENTS_LAVA; if (nativecontents & CONTENTSQ3_BODY) supercontents |= SUPERCONTENTS_BODY; if (nativecontents & CONTENTSQ3_CORPSE) @@ -6114,6 +6845,7 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) 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; @@ -6186,142 +6918,582 @@ void Mod_Q3BSP_Load(dp_model_t *mod, void *buffer, void *bufferend) Mod_Q3BSP_LoadPVS(&header->lumps[Q3LUMP_PVS]); loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models; - // the MakePortals code works fine on the q3bsp data as well - Mod_Q1BSP_MakePortals(); + // the MakePortals code works fine on the q3bsp data as well + Mod_Q1BSP_MakePortals(); + + // FIXME: shader alpha should replace r_wateralpha support in q3bsp + loadmodel->brush.supportwateralpha = true; + + // make a single combined shadow mesh to allow optimized shadow volume creation + numshadowmeshtriangles = 0; + if (cls.state != ca_dedicated) + { + for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) + { + surface->num_firstshadowmeshtriangle = numshadowmeshtriangles; + numshadowmeshtriangles += surface->num_triangles; + } + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true); + for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) + if (surface->num_triangles > 0) + Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); + loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); + if (loadmodel->brush.shadowmesh) + 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); + + 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++) + { + if (i > 0) + { + char name[10]; + // duplicate the basic information + dpsnprintf(name, sizeof(name), "*%i", i); + mod = Mod_FindName(name, loadmodel->name); + // copy the base model to this one + *mod = *loadmodel; + // rename the clone back to its proper name + strlcpy(mod->name, name, sizeof(mod->name)); + mod->brush.parentmodel = loadmodel; + // 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.BoxTouchingLeafPVS = NULL; + mod->brush.BoxTouchingVisibleLeafs = NULL; + mod->brush.FindBoxClusters = NULL; + mod->brush.LightPoint = NULL; + 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; + 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->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces)); + Mod_MakeSortedSurfaces(mod); + + VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins); + VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs); + // enlarge the bounding box to enclose all geometry of this model, + // because q3map2 sometimes lies (mostly to affect the lightgrid), + // which can in turn mess up the farclip (as well as culling when + // outside the level - an unimportant concern) + + //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); + for (j = 0;j < mod->nummodelsurfaces;j++) + { + const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface; + const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex; + int k; + if (!surface->num_vertices) + continue; + for (k = 0;k < surface->num_vertices;k++, v += 3) + { + mod->normalmins[0] = min(mod->normalmins[0], v[0]); + mod->normalmins[1] = min(mod->normalmins[1], v[1]); + mod->normalmins[2] = min(mod->normalmins[2], v[2]); + mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]); + mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]); + mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]); + } + } + //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); + 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])); + modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]); + yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]); + mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius; + mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius; + mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius; + mod->yawmins[0] = mod->yawmins[1] = -yawradius; + mod->yawmins[2] = mod->normalmins[2]; + mod->yawmaxs[2] = mod->normalmaxs[2]; + mod->radius = modelradius; + mod->radius2 = modelradius * modelradius; + + // this gets altered below if sky or water is used + mod->DrawSky = NULL; + mod->DrawAddWaterPlanes = NULL; + + for (j = 0;j < mod->nummodelsurfaces;j++) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_SKY) + break; + if (j < mod->nummodelsurfaces) + mod->DrawSky = R_Q1BSP_DrawSky; + + for (j = 0;j < mod->nummodelsurfaces;j++) + if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA)) + break; + if (j < mod->nummodelsurfaces) + mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; + + Mod_MakeCollisionBIH(mod, false); + + // generate VBOs and other shared data before cloning submodels + if (i == 0) + Mod_BuildVBOs(); + } + + Con_DPrintf("Stats for q3bsp model \"%s\": %i faces, %i nodes, %i leafs, %i clusters, %i clusterportals, mesh: %i vertices, %i triangles, %i surfaces\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->num_surfaces); +} + +void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ + int i = LittleLong(((int *)buffer)[1]); + if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE) + Mod_Q3BSP_Load(mod,buffer, bufferend); + else if (i == Q2BSPVERSION) + Mod_Q2BSP_Load(mod,buffer, bufferend); + else + Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i); +} + +void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ + Host_Error("Mod_MAP_Load: not yet implemented"); +} + +#define OBJASMODEL + +#ifdef OBJASMODEL +typedef struct objvertex_s +{ + int nextindex; + int textureindex; + float v[3]; + float vt[2]; + float vn[3]; +} +objvertex_t; + +void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) +{ + const char *textbase = (char *)buffer, *text = textbase; + char *s; + char *argv[512]; + char line[1024]; + char materialname[MAX_QPATH]; + int i, j, numvertices, firstvertex, firsttriangle, elementindex, vertexindex, numsurfaces, surfacevertices, surfacetriangles, surfaceelements; + int index1, index2, index3; + objvertex_t vfirst, vprev, vcurrent; + int argc; + int linelen; + int numtriangles = 0; + int maxtriangles = 0; + objvertex_t *vertices = NULL; + int linenumber = 0; + int maxtextures = 0, numtextures = 0, textureindex = 0; + int maxv = 0, numv = 1; + int maxvt = 0, numvt = 1; + int maxvn = 0, numvn = 1; + char *texturenames = NULL; + float dist, modelradius, modelyawradius; + float *v = NULL; + float *vt = NULL; + float *vn = NULL; + float mins[3]; + float maxs[3]; + objvertex_t *thisvertex = NULL; + int vertexhashindex; + int *vertexhashtable = NULL; + objvertex_t *vertexhashdata = NULL; + objvertex_t *vdata = NULL; + int vertexhashsize = 0; + int vertexhashcount = 0; + skinfile_t *skinfiles = NULL; + unsigned char *data = NULL; + + memset(&vfirst, 0, sizeof(vfirst)); + memset(&vprev, 0, sizeof(vprev)); + memset(&vcurrent, 0, sizeof(vcurrent)); + + dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name); + + loadmodel->modeldatatypestring = "OBJ"; + + loadmodel->type = mod_obj; + loadmodel->soundfromcenter = true; + loadmodel->TraceBox = Mod_CollisionBIH_TraceBox; + loadmodel->TraceLine = Mod_CollisionBIH_TraceLine; + loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh; + loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh; + loadmodel->brush.TraceLineOfSight = NULL; + loadmodel->brush.SuperContentsFromNativeContents = NULL; + loadmodel->brush.NativeContentsFromSuperContents = NULL; + loadmodel->brush.GetPVS = NULL; + loadmodel->brush.FatPVS = NULL; + loadmodel->brush.BoxTouchingPVS = NULL; + loadmodel->brush.BoxTouchingLeafPVS = NULL; + loadmodel->brush.BoxTouchingVisibleLeafs = NULL; + loadmodel->brush.FindBoxClusters = NULL; + loadmodel->brush.LightPoint = NULL; + loadmodel->brush.FindNonSolidLocation = NULL; + loadmodel->brush.AmbientSoundLevelsForPoint = NULL; + loadmodel->brush.RoundUpToHullSize = NULL; + loadmodel->brush.PointInLeaf = NULL; + 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; + loadmodel->CompileShadowVolume = R_Q1BSP_CompileShadowVolume; + loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; + loadmodel->DrawLight = R_Q1BSP_DrawLight; + + skinfiles = Mod_LoadSkinFiles(); + if (loadmodel->numskins < 1) + loadmodel->numskins = 1; + + // make skinscenes for the skins (no groups) + loadmodel->skinscenes = (animscene_t *)Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins); + for (i = 0;i < loadmodel->numskins;i++) + { + loadmodel->skinscenes[i].firstframe = i; + loadmodel->skinscenes[i].framecount = 1; + loadmodel->skinscenes[i].loop = true; + loadmodel->skinscenes[i].framerate = 10; + } + + VectorClear(mins); + VectorClear(maxs); + + // parse the OBJ text now + for(;;) + { + if (!*text) + break; + linenumber++; + linelen = 0; + for (linelen = 0;text[linelen] && text[linelen] != '\r' && text[linelen] != '\n';linelen++) + line[linelen] = text[linelen]; + line[linelen] = 0; + for (argc = 0;argc < 4;argc++) + argv[argc] = ""; + argc = 0; + s = line; + while (*s == ' ' || *s == '\t') + s++; + while (*s) + { + argv[argc++] = s; + while (*s > ' ') + s++; + if (!*s) + break; + *s++ = 0; + while (*s == ' ' || *s == '\t') + s++; + } + text += linelen; + if (*text == '\r') + text++; + if (*text == '\n') + text++; + if (!argc) + continue; + if (argv[0][0] == '#') + continue; + if (!strcmp(argv[0], "v")) + { + if (maxv <= numv) + { + maxv = max(maxv * 2, 1024); + v = (float *)Mem_Realloc(tempmempool, v, maxv * sizeof(float[3])); + } + v[numv*3+0] = atof(argv[1]); + v[numv*3+2] = atof(argv[2]); + v[numv*3+1] = atof(argv[3]); + numv++; + } + else if (!strcmp(argv[0], "vt")) + { + if (maxvt <= numvt) + { + maxvt = max(maxvt * 2, 1024); + vt = (float *)Mem_Realloc(tempmempool, vt, maxvt * sizeof(float[2])); + } + vt[numvt*2+0] = atof(argv[1]); + vt[numvt*2+1] = 1-atof(argv[2]); + numvt++; + } + else if (!strcmp(argv[0], "vn")) + { + if (maxvn <= numvn) + { + maxvn = max(maxvn * 2, 1024); + vn = (float *)Mem_Realloc(tempmempool, vn, maxvn * sizeof(float[3])); + } + vn[numvn*3+0] = atof(argv[1]); + vn[numvn*3+2] = atof(argv[2]); + vn[numvn*3+1] = atof(argv[3]); + numvn++; + } + else if (!strcmp(argv[0], "f")) + { + if (!numtextures) + { + if (maxtextures <= numtextures) + { + maxtextures = max(maxtextures * 2, 256); + texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH); + } + textureindex = numtextures++; + strlcpy(texturenames + textureindex*MAX_QPATH, loadmodel->name, MAX_QPATH); + } + for (j = 1;j < argc;j++) + { + index1 = atoi(argv[j]); + while(argv[j][0] && argv[j][0] != '/') + argv[j]++; + if (argv[j][0]) + argv[j]++; + index2 = atoi(argv[j]); + while(argv[j][0] && argv[j][0] != '/') + argv[j]++; + if (argv[j][0]) + argv[j]++; + index3 = atoi(argv[j]); + // negative refers to a recent vertex + // zero means not specified + // positive means an absolute vertex index + if (index1 < 0) + index1 = numv - index1; + if (index2 < 0) + index2 = numvt - index2; + if (index3 < 0) + index3 = numvn - index3; + vcurrent.nextindex = -1; + vcurrent.textureindex = textureindex; + VectorCopy(v + 3*index1, vcurrent.v); + Vector2Copy(vt + 2*index2, vcurrent.vt); + VectorCopy(vn + 3*index3, vcurrent.vn); + if (numtriangles == 0) + { + VectorCopy(vcurrent.v, mins); + VectorCopy(vcurrent.v, maxs); + } + else + { + mins[0] = min(mins[0], vcurrent.v[0]); + mins[1] = min(mins[1], vcurrent.v[1]); + mins[2] = min(mins[2], vcurrent.v[2]); + maxs[0] = max(maxs[0], vcurrent.v[0]); + maxs[1] = max(maxs[1], vcurrent.v[1]); + maxs[2] = max(maxs[2], vcurrent.v[2]); + } + if (j == 1) + vfirst = vcurrent; + else if (j >= 3) + { + if (maxtriangles <= numtriangles) + { + maxtriangles = max(maxtriangles * 2, 32768); + vertices = (objvertex_t*)Mem_Realloc(loadmodel->mempool, vertices, maxtriangles * sizeof(objvertex_t[3])); + } + vertices[numtriangles*3+0] = vfirst; + vertices[numtriangles*3+1] = vprev; + vertices[numtriangles*3+2] = vcurrent; + numtriangles++; + } + vprev = vcurrent; + } + } + else if (!strcmp(argv[0], "o") || !strcmp(argv[0], "g")) + ; + else if (!strcmp(argv[0], "usemtl")) + { + for (i = 0;i < numtextures;i++) + if (!strcmp(texturenames+i*MAX_QPATH, argv[1])) + break; + if (i < numtextures) + textureindex = i; + else + { + if (maxtextures <= numtextures) + { + maxtextures = max(maxtextures * 2, 256); + texturenames = (char *)Mem_Realloc(loadmodel->mempool, texturenames, maxtextures * MAX_QPATH); + } + textureindex = numtextures++; + strlcpy(texturenames + textureindex*MAX_QPATH, argv[1], MAX_QPATH); + } + } + } + + // now that we have the OBJ data loaded as-is, we can convert it - // FIXME: shader alpha should replace r_wateralpha support in q3bsp - loadmodel->brush.supportwateralpha = true; + // copy the model bounds, then enlarge the yaw and rotated bounds according to radius + VectorCopy(mins, loadmodel->normalmins); + VectorCopy(maxs, loadmodel->normalmaxs); + dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0])); + modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1])); + modelyawradius = dist*dist+modelyawradius*modelyawradius; + modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2])); + modelradius = modelyawradius + modelradius * modelradius; + modelyawradius = sqrt(modelyawradius); + modelradius = sqrt(modelradius); + loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius; + loadmodel->yawmins[2] = loadmodel->normalmins[2]; + loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = modelyawradius; + loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2]; + loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius; + loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = modelradius; + loadmodel->radius = modelradius; + loadmodel->radius2 = modelradius * modelradius; + + // allocate storage for triangles + loadmodel->num_surfaces = loadmodel->nummodelsurfaces = numsurfaces = numtextures; + loadmodel->surfmesh.data_element3i = Mem_Alloc(loadmodel->mempool, numtriangles * sizeof(int[3])); + loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t)); + // allocate vertex hash structures to build an optimal vertex subset + vertexhashsize = numtriangles*2; + vertexhashtable = Mem_Alloc(loadmodel->mempool, sizeof(int) * vertexhashsize); + memset(vertexhashtable, 0xFF, sizeof(int) * vertexhashsize); + vertexhashdata = Mem_Alloc(loadmodel->mempool, sizeof(*vertexhashdata) * numtriangles*3); + vertexhashcount = 0; + + // gather surface stats for assigning vertex/triangle ranges + firstvertex = 0; + firsttriangle = 0; + elementindex = 0; + for (textureindex = 0;textureindex < numtextures;textureindex++) + { + msurface_t *surface = loadmodel->data_surfaces + textureindex; + // copy the mins/maxs of the model backwards so that the first vertex + // added will set the surface bounds to a point + VectorCopy(loadmodel->normalmaxs, surface->mins); + VectorCopy(loadmodel->normalmins, surface->maxs); + surfacevertices = 0; + surfaceelements = 0; + for (vertexindex = 0;vertexindex < numtriangles*3;vertexindex++) + { + thisvertex = vertices + vertexindex; + if (thisvertex->textureindex != textureindex) + continue; + surface->mins[0] = min(surface->mins[0], thisvertex->v[0]); + surface->mins[1] = min(surface->mins[1], thisvertex->v[1]); + surface->mins[2] = min(surface->mins[2], thisvertex->v[2]); + surface->maxs[0] = max(surface->maxs[0], thisvertex->v[0]); + surface->maxs[1] = max(surface->maxs[1], thisvertex->v[1]); + surface->maxs[2] = max(surface->maxs[2], thisvertex->v[2]); + vertexhashindex = (unsigned int)(thisvertex->v[0] * 3571 + thisvertex->v[0] * 1777 + thisvertex->v[0] * 457) % (unsigned int)vertexhashsize; + for (i = vertexhashtable[vertexhashindex];i >= 0;i = vertexhashdata[i].nextindex) + { + vdata = vertexhashdata + i; + if (vdata->textureindex == thisvertex->textureindex && VectorCompare(thisvertex->v, vdata->v) && VectorCompare(thisvertex->vn, vdata->vn) && Vector2Compare(thisvertex->vt, vdata->vt)) + break; + } + if (i < 0) + { + i = vertexhashcount++; + vdata = vertexhashdata + i; + *vdata = *thisvertex; + vdata->nextindex = vertexhashtable[vertexhashindex]; + vertexhashtable[vertexhashindex] = i; + surfacevertices++; + } + loadmodel->surfmesh.data_element3i[elementindex++] = i; + surfaceelements++; + } + surfacetriangles = surfaceelements / 3; + surface->num_vertices = surfacevertices; + surface->num_triangles = surfacetriangles; + surface->num_firstvertex = firstvertex; + surface->num_firsttriangle = firsttriangle; + firstvertex += surface->num_vertices; + firsttriangle += surface->num_triangles; + } + numvertices = firstvertex; + + // allocate storage for final mesh data + loadmodel->num_textures = numtextures * loadmodel->numskins; + loadmodel->num_texturesperskin = numtextures; + data = (unsigned char *)Mem_Alloc(loadmodel->mempool, numsurfaces * sizeof(int) + numsurfaces * loadmodel->numskins * sizeof(texture_t) + numtriangles * sizeof(int[3]) + (numvertices <= 65536 ? numtriangles * sizeof(unsigned short[3]) : 0) + numvertices * sizeof(float[14])); + loadmodel->sortedmodelsurfaces = (int *)data;data += numsurfaces * sizeof(int); + loadmodel->data_textures = (texture_t *)data;data += numsurfaces * loadmodel->numskins * sizeof(texture_t); + loadmodel->surfmesh.num_vertices = numvertices; + loadmodel->surfmesh.num_triangles = numtriangles; + loadmodel->surfmesh.data_neighbor3i = (int *)data;data += numtriangles * sizeof(int[3]); + loadmodel->surfmesh.data_vertex3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_svector3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_tvector3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_normal3f = (float *)data;data += numvertices * sizeof(float[3]); + loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += numvertices * sizeof(float[2]); + if (loadmodel->surfmesh.num_vertices <= 65536) + loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]); - // make a single combined shadow mesh to allow optimized shadow volume creation - numshadowmeshtriangles = 0; - if (cls.state != ca_dedicated) + for (j = 0;j < loadmodel->surfmesh.num_vertices;j++) { - for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) - { - surface->num_firstshadowmeshtriangle = numshadowmeshtriangles; - numshadowmeshtriangles += surface->num_triangles; - } - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true); - for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++) - if (surface->num_triangles > 0) - Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)); - loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false); - Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles); + VectorCopy(vertexhashdata[j].v, loadmodel->surfmesh.data_vertex3f + 3*j); + VectorCopy(vertexhashdata[j].vn, loadmodel->surfmesh.data_normal3f + 3*j); + Vector2Copy(vertexhashdata[j].vt, loadmodel->surfmesh.data_texcoordtexture2f + 2*j); } - loadmodel->brush.num_leafs = 0; - Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes); + // load the textures + for (textureindex = 0;textureindex < numtextures;textureindex++) + Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + textureindex, skinfiles, texturenames + textureindex*MAX_QPATH, texturenames + textureindex*MAX_QPATH); + Mod_FreeSkinFiles(skinfiles); - mod = loadmodel; - for (i = 0;i < loadmodel->brush.numsubmodels;i++) + // set the surface textures + for (textureindex = 0;textureindex < numtextures;textureindex++) { - if (i > 0) - { - char name[10]; - // duplicate the basic information - dpsnprintf(name, sizeof(name), "*%i", i); - mod = Mod_FindName(name, loadmodel->name); - // copy the base model to this one - *mod = *loadmodel; - // rename the clone back to its proper name - strlcpy(mod->name, name, sizeof(mod->name)); - mod->brush.parentmodel = loadmodel; - // 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.BoxTouchingLeafPVS = NULL; - mod->brush.BoxTouchingVisibleLeafs = NULL; - mod->brush.FindBoxClusters = NULL; - mod->brush.LightPoint = NULL; - mod->brush.AmbientSoundLevelsForPoint = NULL; - } - mod->brush.submodel = i; + msurface_t *surface = loadmodel->data_surfaces + textureindex; + surface->texture = loadmodel->data_textures + textureindex; + } - // 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->sortedmodelsurfaces = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->sortedmodelsurfaces)); - Mod_MakeSortedSurfaces(mod); + // free data + Mem_Free(vertices); + Mem_Free(texturenames); + Mem_Free(v); + Mem_Free(vt); + Mem_Free(vn); + Mem_Free(vertexhashtable); + Mem_Free(vertexhashdata); + + // compute all the mesh information that was not loaded from the file + Mod_MakeSortedSurfaces(loadmodel); + if (loadmodel->surfmesh.data_element3s) + for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++) + loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i]; + Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__); + // generate normals if the file did not have them + if (!VectorLength2(loadmodel->surfmesh.data_normal3f)) + Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true); + Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true); + Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles); + + Mod_MakeCollisionBIH(loadmodel, true); +} - VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins); - VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs); - // enlarge the bounding box to enclose all geometry of this model, - // because q3map2 sometimes lies (mostly to affect the lightgrid), - // which can in turn mess up the farclip (as well as culling when - // outside the level - an unimportant concern) - //printf("Editing model %d... BEFORE re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); - for (j = 0;j < mod->nummodelsurfaces;j++) - { - const msurface_t *surface = mod->data_surfaces + j + mod->firstmodelsurface; - const float *v = mod->surfmesh.data_vertex3f + 3 * surface->num_firstvertex; - int k; - if (!surface->num_vertices) - continue; - for (k = 0;k < surface->num_vertices;k++, v += 3) - { - mod->normalmins[0] = min(mod->normalmins[0], v[0]); - mod->normalmins[1] = min(mod->normalmins[1], v[1]); - mod->normalmins[2] = min(mod->normalmins[2], v[2]); - mod->normalmaxs[0] = max(mod->normalmaxs[0], v[0]); - mod->normalmaxs[1] = max(mod->normalmaxs[1], v[1]); - mod->normalmaxs[2] = max(mod->normalmaxs[2], v[2]); - } - } - //printf("Editing model %d... AFTER re-bounding: %f %f %f - %f %f %f\n", i, mod->normalmins[0], mod->normalmins[1], mod->normalmins[2], mod->normalmaxs[0], mod->normalmaxs[1], mod->normalmaxs[2]); - 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])); - modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]); - yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]); - mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius; - mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius; - mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius; - mod->yawmins[0] = mod->yawmins[1] = -yawradius; - mod->yawmins[2] = mod->normalmins[2]; - mod->yawmaxs[2] = mod->normalmaxs[2]; - mod->radius = modelradius; - mod->radius2 = modelradius * modelradius; - // this gets altered below if sky or water is used - mod->DrawSky = NULL; - mod->DrawAddWaterPlanes = NULL; - for (j = 0;j < mod->nummodelsurfaces;j++) - if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & MATERIALFLAG_SKY) - break; - if (j < mod->nummodelsurfaces) - mod->DrawSky = R_Q1BSP_DrawSky; - for (j = 0;j < mod->nummodelsurfaces;j++) - if (mod->data_surfaces[j + mod->firstmodelsurface].texture->basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION)) - break; - if (j < mod->nummodelsurfaces) - mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes; - } -} -void Mod_IBSP_Load(dp_model_t *mod, void *buffer, void *bufferend) -{ - int i = LittleLong(((int *)buffer)[1]); - if (i == Q3BSPVERSION || i == Q3BSPVERSION_IG || i == Q3BSPVERSION_LIVE) - Mod_Q3BSP_Load(mod,buffer, bufferend); - else if (i == Q2BSPVERSION) - Mod_Q2BSP_Load(mod,buffer, bufferend); - else - Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i); -} -void Mod_MAP_Load(dp_model_t *mod, void *buffer, void *bufferend) -{ - Host_Error("Mod_MAP_Load: not yet implemented"); -} + + +#else // OBJASMODEL + +#ifdef OBJWORKS typedef struct objvertex_s { float v[3]; @@ -6334,12 +7506,405 @@ typedef struct objtriangle_s { objvertex_t vertex[3]; int textureindex; + // these fields are used only in conversion to surfaces + int axis; + int surfaceindex; + int surfacevertexindex[3]; + float edgeplane[3][4]; } objtriangle_t; +typedef objnode_s +{ + struct objnode_s *children[2]; + struct objnode_s *parent; + objtriangle_t *triangles; + float normal[3]; + float dist; + float mins[3]; + float maxs[3]; + int numtriangles; +} +objnode_t; + +objnode_t *Mod_OBJ_BSPNodeForTriangles(objnode_t *parent, objtriangle_t *triangles, int numtriangles, const float *mins, const float *maxs, mem_expandablearray_t *nodesarray, int maxclippedtriangles, objtriangle_t *clippedfronttriangles, objtriangle_t *clippedbacktriangles) +{ + int i, j; + float normal[3]; + float dist; + int score; + float bestnormal[3]; + float bestdist; + int bestscore; + float mins[3]; + float maxs[3]; + int numfronttriangles; + int numbacktriangles; + int count_front; + int count_back; + int count_both; + int count_on; + float outfrontpoints[5][3]; + float outbackpoints[5][3]; + int neededfrontpoints; + int neededbackpoints; + int countonpoints; + objnode_t *node; + + node = (objnode_t *)Mem_ExpandableArray_AllocRecord(array); + node->parent = parent; + if (numtriangles) + { + VectorCopy(triangles[0].vertex[0].v, mins); + VectorCopy(triangles[0].vertex[0].v, maxs); + } + else if (parent && parent->children[0] == node) + { + VectorCopy(parent->mins, mins); + Vectorcopy(parent->maxs, maxs); + } + else if (parent && parent->children[1] == node) + { + VectorCopy(parent->mins, mins); + Vectorcopy(parent->maxs, maxs); + } + else + { + VectorClear(mins); + VectorClear(maxs); + } + for (i = 0;i < numtriangles;i++) + { + for (j = 0;j < 3;j++) + { + mins[0] = min(mins[0], triangles[i].vertex[j].v[0]); + mins[1] = min(mins[1], triangles[i].vertex[j].v[1]); + mins[2] = min(mins[2], triangles[i].vertex[j].v[2]); + maxs[0] = max(maxs[0], triangles[i].vertex[j].v[0]); + maxs[1] = max(maxs[1], triangles[i].vertex[j].v[1]); + maxs[2] = max(maxs[2], triangles[i].vertex[j].v[2]); + } + } + VectorCopy(mins, node->mins); + VectorCopy(maxs, node->maxs); + if (numtriangles <= mod_obj_leaftriangles.integer) + { + // create a leaf + loadmodel->brush.num_leafs++; + node->triangles = triangles; + node->numtriangles = numtriangles; + return node; + } + + // create a node + loadmodel->brush.num_nodes++; + // pick a splitting plane from the various choices available to us... + // early splits simply halve the interval + bestscore = 0; + VectorClear(bestnormal); + bestdist = 0; + if (numtriangles <= mod_obj_splitterlimit.integer) + limit = numtriangles; + else + limit = 0; + for (i = -3;i < limit;i++) + { + if (i < 0) + { + // first we try 3 axial splits (kdtree-like) + j = i + 3; + VectorClear(normal); + normal[j] = 1; + dist = (mins[j] + maxs[j]) * 0.5f; + } + else + { + // then we try each triangle plane + TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal); + VectorNormalize(normal); + dist = DotProduct(normal, triangles[i].vertex[0].v); + // use positive axial values whenever possible + if (normal[0] == -1) + normal[0] = 1; + if (normal[1] == -1) + normal[1] = 1; + if (normal[2] == -1) + normal[2] = 1; + // skip planes that match the current best + if (VectorCompare(normal, bestnormal) && dist == bestdist) + continue; + } + count_on = 0; + count_front = 0; + count_back = 0; + count_both = 0; + for (j = 0;j < numtriangles;j++) + { + dists[0] = DotProduct(normal, triangles[j].vertex[0].v) - dist; + dists[1] = DotProduct(normal, triangles[j].vertex[1].v) - dist; + dists[2] = DotProduct(normal, triangles[j].vertex[2].v) - dist; + if (dists[0] < -DIST_EPSILON || dists[1] < -DIST_EPSILON || dists[2] < -DIST_EPSILON) + { + if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON) + count_both++; + else + count_back++; + } + else if (dists[0] > DIST_EPSILON || dists[1] > DIST_EPSILON || dists[2] > DIST_EPSILON) + count_front++; + else + count_on++; + } + // score is supposed to: + // prefer axial splits + // prefer evenly dividing the input triangles + // prefer triangles on the plane + // avoid triangles crossing the plane + score = count_on*count_on - count_both*count_both + min(count_front, count_back)*(count_front+count_back); + if (normal[0] == 1 || normal[1] == 1 || normal[2] == 1) + score *= 2; + if (i == -3 || bestscore < score) + { + VectorCopy(normal, bestnormal); + bestdist = dist; + bestscore = score; + } + } + + // now we have chosen an optimal split plane... + + // divide triangles by the splitting plane + numfronttriangles = 0; + numbacktriangles = 0; + for (i = 0;i < numtriangles;i++) + { + neededfrontpoints = 0; + neededbackpoints = 0; + countonpoints = 0; + PolygonF_Divide(3, triangles[i].vertex[0].v, bestnormal[0], bestnormal[1], bestnormal[2], bestdist, DIST_EPSILON, 5, outfrontpoints[0], &neededfrontpoints, 5, outbackpoints[0], &neededbackpoints, &countonpoints); + if (countonpoints > 1) + { + // triangle lies on plane, assign it to one child only + TriangleNormal(triangles[i].vertex[0].v, triangles[i].vertex[1].v, triangles[i].vertex[2].v, normal); + if (DotProduct(bestnormal, normal) >= 0) + { + // assign to front side child + obj_fronttriangles[numfronttriangles++] = triangles[i]; + } + else + { + // assign to back side child + obj_backtriangles[numbacktriangles++] = triangles[i]; + } + } + else + { + // convert clipped polygons to triangles + for (j = 0;j < neededfrontpoints-2;j++) + { + obj_fronttriangles[numfronttriangles] = triangles[i]; + VectorCopy(outfrontpoints[0], obj_fronttriangles[numfronttriangles].vertex[0].v); + VectorCopy(outfrontpoints[j+1], obj_fronttriangles[numfronttriangles].vertex[1].v); + VectorCopy(outfrontpoints[j+2], obj_fronttriangles[numfronttriangles].vertex[2].v); + numfronttriangles++; + } + for (j = 0;j < neededbackpoints-2;j++) + { + obj_backtriangles[numbacktriangles] = triangles[i]; + VectorCopy(outbackpoints[0], obj_backtriangles[numbacktriangles].vertex[0].v); + VectorCopy(outbackpoints[j+1], obj_backtriangles[numbacktriangles].vertex[1].v); + VectorCopy(outbackpoints[j+2], obj_backtriangles[numbacktriangles].vertex[2].v); + numbacktriangles++; + } + } + } + + // now copy the triangles out of the big buffer + if (numfronttriangles) + { + fronttriangles = Mem_Alloc(loadmodel->mempool, fronttriangles * sizeof(*fronttriangles)); + memcpy(fronttriangles, obj_fronttriangles, numfronttriangles * sizeof(*fronttriangles)); + } + else + fronttriangles = NULL; + if (numbacktriangles) + { + backtriangles = Mem_Alloc(loadmodel->mempool, backtriangles * sizeof(*backtriangles)); + memcpy(backtriangles, obj_backtriangles, numbacktriangles * sizeof(*backtriangles)); + } + else + backtriangles = NULL; + + // free the original triangles we were given + if (triangles) + Mem_Free(triangles); + triangles = NULL; + numtriangles = 0; + + // now create the children... + node->children[0] = Mod_OBJ_BSPNodeForTriangles(node, fronttriangles, numfronttriangles, frontmins, frontmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + node->children[1] = Mod_OBJ_BSPNodeForTriangles(node, backtriangles, numbacktriangles, backmins, backmaxs, nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + return node; +} + +void Mod_OBJ_SnapVertex(float *v) +{ + int i; + float a = mod_obj_vertexprecision.value; + float b = 1.0f / a; + v[0] -= floor(v[0] * a + 0.5f) * b; + v[1] -= floor(v[1] * a + 0.5f) * b; + v[2] -= floor(v[2] * a + 0.5f) * b; +} + +void Mod_OBJ_ConvertBSPNode(objnode_t *objnode, mnode_t *mnodeparent) +{ + if (objnode->children[0]) + { + // convert to mnode_t + mnode_t *mnode = loadmodel->brush.data_nodes + loadmodel->brush.num_nodes++; + mnode->parent = mnodeparent; + mnode->plane = loadmodel->brush.data_planes + loadmodel->brush.num_planes++; + VectorCopy(objnode->normal, mnode->plane->normal); + mnode->plane->dist = objnode->dist; + PlaneClassify(mnode->plane); + VectorCopy(objnode->mins, mnode->mins); + VectorCopy(objnode->maxs, mnode->maxs); + // push combinedsupercontents up to the parent + if (mnodeparent) + mnodeparent->combinedsupercontents |= mnode->combinedsupercontents; + mnode->children[0] = Mod_OBJ_ConvertBSPNode(objnode->children[0], mnode); + mnode->children[1] = Mod_OBJ_ConvertBSPNode(objnode->children[1], mnode); + } + else + { + // convert to mleaf_t + mleaf_t *mleaf = loadmodel->brush.data_leafs + loadmodel->brush.num_leafs++; + mleaf->parent = mnodeparent; + VectorCopy(objnode->mins, mleaf->mins); + VectorCopy(objnode->maxs, mleaf->maxs); + mleaf->clusterindex = loadmodel->brush.num_leafs - 1; + if (objnode->numtriangles) + { + objtriangle_t *triangles = objnode->triangles; + int numtriangles = objnode->numtriangles; + texture_t *texture; + float edge[3][3]; + float normal[3]; + objvertex_t vertex[3]; + numsurfaces = 0; + maxsurfaces = numtriangles; + surfaces = NULL; + // calculate some more data on each triangle for surface gathering + for (i = 0;i < numtriangles;i++) + { + triangle = triangles + i; + texture = loadmodel->data_textures + triangle->textureindex; + Mod_OBJ_SnapVertex(triangle->vertex[0].v); + Mod_OBJ_SnapVertex(triangle->vertex[1].v); + Mod_OBJ_SnapVertex(triangle->vertex[2].v); + TriangleNormal(triangle->vertex[0].v, triangle->vertex[1].v, triangle->vertex[2].v, normal); + axis = 0; + if (fabs(normal[axis]) < fabs(normal[1])) + axis = 1; + if (fabs(normal[axis]) < fabs(normal[2])) + axis = 2; + VectorClear(normal); + normal[axis] = 1; + triangle->axis = axis; + VectorSubtract(triangle->vertex[1].v, triangle->vertex[0].v, edge[0]); + VectorSubtract(triangle->vertex[2].v, triangle->vertex[1].v, edge[1]); + VectorSubtract(triangle->vertex[0].v, triangle->vertex[2].v, edge[2]); + CrossProduct(edge[0], normal, triangle->edgeplane[0]); + CrossProduct(edge[1], normal, triangle->edgeplane[1]); + CrossProduct(edge[2], normal, triangle->edgeplane[2]); + VectorNormalize(triangle->edgeplane[0]); + VectorNormalize(triangle->edgeplane[1]); + VectorNormalize(triangle->edgeplane[2]); + triangle->edgeplane[0][3] = DotProduct(triangle->edgeplane[0], triangle->vertex[0].v); + triangle->edgeplane[1][3] = DotProduct(triangle->edgeplane[1], triangle->vertex[1].v); + triangle->edgeplane[2][3] = DotProduct(triangle->edgeplane[2], triangle->vertex[2].v); + triangle->surfaceindex = 0; + // add to the combined supercontents while we're here... + mleaf->combinedsupercontents |= texture->supercontents; + } + surfaceindex = 1; + for (i = 0;i < numtriangles;i++) + { + // skip already-assigned triangles + if (triangles[i].surfaceindex) + continue; + texture = loadmodel->data_textures + triangles[i].textureindex; + // assign a new surface to this triangle + triangles[i].surfaceindex = surfaceindex++; + axis = triangles[i].axis; + numvertices = 3; + // find the triangle's neighbors, this can take multiple passes + retry = true; + while (retry) + { + retry = false; + for (j = i+1;j < numtriangles;j++) + { + if (triangles[j].surfaceindex || triangles[j].axis != axis || triangles[j].texture != texture) + continue; + triangle = triangles + j; + for (k = i;k < j;k++) + { + if (triangles[k].surfaceindex != surfaceindex) + continue; + if (VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[0].v, triangles[j].vertex[2].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[1].v, triangles[j].vertex[2].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[0].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[1].v) + || VectorCompare(triangles[k].vertex[2].v, triangles[j].vertex[2].v)) + { + // shares a vertex position + --- FIXME --- + } + } + for (k = 0;k < numvertices;k++) + if (!VectorCompare(vertex[k].v, triangles[j].vertex[0].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[1].v) || !VectorCompare(vertex[k].v, triangles[j].vertex[2].v)) + break; + if (k == numvertices) + break; // not a neighbor + // this triangle is a neighbor and has the same axis and texture + // check now if it overlaps in lightmap projection space + triangles[j].surfaceindex; + if (triangles[j]. + } + } + //triangles[i].surfaceindex = surfaceindex++; + for (surfaceindex = 0;surfaceindex < numsurfaces;surfaceindex++) + { + if (surfaces[surfaceindex].texture != texture) + continue; + // check if any triangles already in this surface overlap in lightmap projection space + + { + } + break; + } + } + // let the collision code simply use the surfaces + mleaf->containscollisionsurfaces = mleaf->combinedsupercontents != 0; + mleaf->numleafsurfaces = ?; + mleaf->firstleafsurface = ?; + } + // push combinedsupercontents up to the parent + if (mnodeparent) + mnodeparent->combinedsupercontents |= mleaf->combinedsupercontents; + } +} +#endif + void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) { -#if 0 +#ifdef OBJWORKS const char *textbase = (char *)buffer, *text = textbase; char *s; char *argv[512]; @@ -6361,6 +7926,8 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) float *vt = Mem_Alloc(tempmempool, maxvt * sizeof(float[2])); float *vn = Mem_Alloc(tempmempool, maxvn * sizeof(float[3])); objvertex_t vfirst, vprev, vcurrent; + float mins[3]; + float maxs[3]; #if 0 int hashindex; int maxverthash = 65536, numverthash = 0; @@ -6403,6 +7970,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) 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; @@ -6410,6 +7978,9 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume; loadmodel->DrawLight = R_Q1BSP_DrawLight; + VectorClear(mins); + VectorClear(maxs); + // parse the OBJ text now for(;;) { @@ -6521,6 +8092,20 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) VectorCopy(v + 3*index1, vcurrent.v); Vector2Copy(vt + 2*index2, vcurrent.vt); VectorCopy(vn + 3*index3, vcurrent.vn); + if (numtriangles == 0) + { + VectorCopy(vcurrent.v, mins); + VectorCopy(vcurrent.v, maxs); + } + else + { + mins[0] = min(mins[0], vcurrent.v[0]); + mins[1] = min(mins[1], vcurrent.v[1]); + mins[2] = min(mins[2], vcurrent.v[2]); + maxs[0] = max(maxs[0], vcurrent.v[0]); + maxs[1] = max(maxs[1], vcurrent.v[1]); + maxs[2] = max(maxs[2], vcurrent.v[2]); + } if (j == 1) vfirst = vcurrent; else if (j >= 3) @@ -6529,10 +8114,10 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) { objtriangle_t *oldtriangles = triangles; maxtriangles *= 2; - triangles = Mem_Alloc(tempmempool, numtriangles * sizeof(*triangles)); + triangles = Mem_Alloc(tempmempool, maxtriangles * sizeof(*triangles)); if (oldtriangles) { - memcpy(triangles, oldtriangles, numtriangles * sizeof(*triangles)); + memcpy(triangles, oldtriangles, maxtriangles * sizeof(*triangles)); Mem_Free(oldtriangles); } } @@ -6564,7 +8149,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) textures = Mem_Alloc(tempmempool, maxtextures * sizeof(*textures)); if (oldtextures) { - memcpy(textures, oldtextures, numtexutres * sizeof(*textures)); + memcpy(textures, oldtextures, numtextures * sizeof(*textures)); Mem_Free(oldtextures); } } @@ -6586,7 +8171,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) loadmodel->num_textures = numtextures; loadmodel->data_textures = Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t)); for (i = 0;i < numtextures;i++) - Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); + Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, texturenames[i], true, true, TEXF_MIPMAP | TEXF_ALPHA | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS); // free the texturenames array since we are now done with it for (i = 0;i < numtextures;i++) @@ -6597,9 +8182,55 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) Mem_Free(texturenames); texturenames = NULL; + // copy the model bounds, then enlarge the yaw and rotated bounds according to radius + VectorCopy(mins, loadmodel->normalmins); + VectorCopy(maxs, loadmodel->normalmaxs); + dist = max(fabs(loadmodel->normalmins[0]), fabs(loadmodel->normalmaxs[0])); + modelyawradius = max(fabs(loadmodel->normalmins[1]), fabs(loadmodel->normalmaxs[1])); + modelyawradius = dist*dist+modelyawradius*modelyawradius; + modelradius = max(fabs(loadmodel->normalmins[2]), fabs(loadmodel->normalmaxs[2])); + modelradius = modelyawradius + modelradius * modelradius; + modelyawradius = sqrt(modelyawradius); + modelradius = sqrt(modelradius); + loadmodel->yawmins[0] = loadmodel->yawmins[1] = -modelyawradius; + loadmodel->yawmins[2] = loadmodel->normalmins[2]; + loadmodel->yawmaxs[0] = loadmodel->yawmaxs[1] = modelyawradius; + loadmodel->yawmaxs[2] = loadmodel->normalmaxs[2]; + loadmodel->rotatedmins[0] = loadmodel->rotatedmins[1] = loadmodel->rotatedmins[2] = -modelradius; + loadmodel->rotatedmaxs[0] = loadmodel->rotatedmaxs[1] = loadmodel->rotatedmaxs[2] = modelradius; + loadmodel->radius = modelradius; + loadmodel->radius2 = modelradius * modelradius; + + // make sure the temp triangle buffer is big enough for BSP building + maxclippedtriangles = numtriangles*4; + if (numtriangles > 0) + { + clippedfronttriangles = Mem_Alloc(loadmodel->mempool, maxclippedtriangles * 2 * sizeof(objtriangle_t)); + clippedbacktriangles = clippedfronttriangles + maxclippedtriangles; + } + // generate a rough BSP tree from triangle data, we don't have to be too careful here, it only has to define the basic areas of the map + loadmodel->brush.num_leafs = 0; + loadmodel->brush.num_nodes = 0; + Mem_ExpandableArray_NewArray(&nodesarray, loadmodel->mempool, sizeof(objnode_t), 1024); + rootnode = Mod_OBJ_BSPNodeForTriangles(triangles, numtriangles, mins, maxs, &nodesarray, maxclippedtriangles, clippedfronttriangles, clippedbacktriangles); + + // convert the BSP tree to mnode_t and mleaf_t structures and convert the triangles to msurface_t... + loadmodel->brush.data_leafs = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafs * sizeof(mleaf_t)); + loadmodel->brush.data_nodes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mnode_t)); + loadmodel->brush.data_planes = Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(mplane_t)); + loadmodel->brush.num_leafs = 0; + loadmodel->brush.num_nodes = 0; + loadmodel->brush.num_planes = 0; + Mod_OBJ_ConvertAndFreeBSPNode(rootnode); + + if (clippedfronttriangles) + Mem_Free(clippedfronttriangles); + maxclippedtriangles = 0; + clippedfronttriangles = NULL; + clippedbacktriangles = NULL; - // generate surfaces by recursing triangles into BSP tree and ensuring they do not overlap in the lightmap projection axis +--- NOTHING DONE PAST THIS POINT --- loadmodel->numskins = LittleLong(pinmodel->num_skins); numxyz = LittleLong(pinmodel->num_xyz); @@ -6644,7 +8275,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) loadmodel->num_texturesperskin = loadmodel->num_surfaces; loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t)); for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME) - Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP | TEXF_COMPRESS); + Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i * loadmodel->num_surfaces, inskin, true, true, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PICMIP | TEXF_COMPRESS); } else { @@ -6782,6 +8413,7 @@ void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend) loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i]; #endif } +#endif // !OBJASMODEL qboolean Mod_CanSeeBox_Trace(int numsamples, float t, dp_model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX) {