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
}
}
- loadmodel->brush.solidskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_solidtexture", TEXF_PRECACHE, (unsigned char *) solidpixels, w, h);
- loadmodel->brush.alphaskyskinframe = R_SkinFrame_LoadInternalBGRA("sky_alphatexture", TEXF_ALPHA | TEXF_PRECACHE, (unsigned char *) alphapixels, w, h);
+ 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);
}
tx->reflectfactor = 1;
Vector4Set(tx->reflectcolor4f, 1, 1, 1, 1);
tx->r_water_wateralpha = 1;
+ tx->specularscalemod = 1;
+ tx->specularpowermod = 1;
}
if (!m)
}
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
{
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_PRECACHE | TEXF_MIPMAP | (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)
{
// 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)
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))
loadmodel->num_surfaces = count;
+ loadmodel->brushq1.firstrender = true;
loadmodel->brushq1.lightmapupdateflags = (unsigned char *)Mem_Alloc(loadmodel->mempool, count*sizeof(unsigned char));
totalverts = 0;
lightmaptexture = NULL;
deluxemaptexture = r_texture_blanknormalmap;
- lightmapnumber = 1;
+ lightmapnumber = 0;
lightmapsize = bound(256, gl_max_lightmapsize.integer, (int)vid.maxtexturesize_2d);
totallightmapsamples = 0;
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++;
Mod_AllocLightmap_Reset(&allocState);
Mod_AllocLightmap_Block(&allocState, ssize, tsize, &lightmapx, &lightmapy);
}
#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;
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];
Mod_Q1BSP_RecursiveNodePortals(front);
Mod_Q1BSP_RecursiveNodePortals(back);
+
+ portalpointsbufferoffset -= 6*MAX_PORTALPOINTS;
}
static void Mod_Q1BSP_MakePortals(void)
{
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);
}
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;
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]);
Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
}
//mod->brushq1.num_visleafs = bm->visleafs;
- }
- Mod_Q1BSP_LoadMapBrushes();
-
- //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)
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);
+ Mod_LoadTextureFromQ3Shader(out, out->name, true, true, TEXF_MIPMAP | (r_picmipworld.integer ? TEXF_PICMIP : 0) | TEXF_COMPRESS);
}
static void Mod_Q3BSP_LoadPlanes(lump_t *l)
;
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;
{
// 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);
}
}
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)
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;
}
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
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);
- 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);
+ 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);
break;
default:
break;
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;
break;
if (j < mod->nummodelsurfaces)
mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
+
+ // 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)
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 = NULL;
+ loadmodel->TraceLine = NULL;
+ loadmodel->TracePoint = NULL;
+ loadmodel->PointSuperContents = NULL;
+ 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
+
+ // 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]);
+
+ for (j = 0;j < loadmodel->surfmesh.num_vertices;j++)
+ {
+ VectorCopy(vertexhashdata[j].v, loadmodel->surfmesh.data_vertex3f + 3*j);
+ VectorCopy(vertexhashdata[j].vn, loadmodel->surfmesh.data_normal3f + 3*j);
+ VectorCopy(vertexhashdata[j].vt, loadmodel->surfmesh.data_texcoordtexture2f + 2*j);
+ }
+
+ // 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);
+
+ // set the surface textures
+ for (textureindex = 0;textureindex < numtextures;textureindex++)
+ {
+ msurface_t *surface = loadmodel->data_surfaces + textureindex;
+ surface->texture = loadmodel->data_textures + textureindex;
+ }
+
+ // 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);
+}
+
+
+
+
+
+
+
+
+
+
+#else // OBJASMODEL
+
#ifdef OBJWORKS
typedef struct objvertex_s
{
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;
{
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);
}
}
textures = Mem_Alloc(tempmempool, maxtextures * sizeof(*textures));
if (oldtextures)
{
- memcpy(textures, oldtextures, numtexutres * sizeof(*textures));
+ memcpy(textures, oldtextures, numtextures * sizeof(*textures));
Mem_Free(oldtextures);
}
}
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++)
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
{
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)
{
projects / xonotic / darkplaces.git / blobdiff