static model_t mod_known[MAX_MOD_KNOWN];
rtexturepool_t *mod_shared_texturepool;
-rtexture_t *r_notexture;
+rtexture_t *r_texture_notexture;
rtexture_t *mod_shared_detailtextures[NUM_DETAILTEXTURES];
rtexture_t *mod_shared_distorttexture[64];
return;
}
-texture_t r_surf_notexture;
-
void Mod_SetupNoTexture(void)
{
- int x, y;
- qbyte pix[16][16][4];
-
- // this makes a light grey/dark grey checkerboard texture
- for (y = 0;y < 16;y++)
- {
- for (x = 0;x < 16;x++)
- {
- if ((y < 8) ^ (x < 8))
- {
- pix[y][x][0] = 128;
- pix[y][x][1] = 128;
- pix[y][x][2] = 128;
- pix[y][x][3] = 255;
- }
- else
- {
- pix[y][x][0] = 64;
- pix[y][x][1] = 64;
- pix[y][x][2] = 64;
- pix[y][x][3] = 255;
- }
- }
- }
-
- r_notexture = R_LoadTexture2D(mod_shared_texturepool, "notexture", 16, 16, &pix[0][0][0], TEXTYPE_RGBA, TEXF_MIPMAP, NULL);
}
static void mod_start(void)
static void mod_newmap(void)
{
+ msurface_t *surface;
+ int i, surfacenum, ssize, tsize;
+
+ if (!cl_stainmaps_clearonload.integer)
+ return;
+
+ for (i = 0;i < MAX_MOD_KNOWN;i++)
+ {
+ if (mod_known[i].name[0])
+ {
+ for (surfacenum = 0, surface = mod_known[i].brush.data_surfaces;surfacenum < mod_known[i].brush.num_surfaces;surfacenum++, surface++)
+ {
+ if (surface->lightmapinfo && surface->lightmapinfo->stainsamples)
+ {
+ ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
+ tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
+ memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
+ surface->cached_dlight = true;
+ }
+ }
+ }
+ }
}
/*
Mod_FreeModel(mod);
strcpy(mod->name, name);
mod->isworldmodel = isworldmodel;
- mod->needload = true;
+ mod->loaded = false;
}
/*
crc = 0;
buf = NULL;
if (mod->isworldmodel != isworldmodel)
- mod->needload = true;
- if (mod->needload || checkdisk)
+ mod->loaded = false;
+ if (!mod->loaded || checkdisk)
{
- if (checkdisk && !mod->needload)
+ if (checkdisk && mod->loaded)
Con_DPrintf("checking model %s\n", mod->name);
buf = FS_LoadFile (mod->name, tempmempool, false);
if (buf)
{
crc = CRC_Block(buf, fs_filesize);
if (mod->crc != crc)
- mod->needload = true;
+ mod->loaded = false;
}
}
- if (!mod->needload)
+ if (mod->loaded)
return mod; // already loaded
Con_DPrintf("loading model %s\n", mod->name);
// LordHavoc: unload the existing model in this slot (if there is one)
Mod_UnloadModel(mod);
+
// load the model
mod->isworldmodel = isworldmodel;
mod->used = true;
mod->crc = crc;
- // errors can prevent the corresponding mod->needload = false;
- mod->needload = true;
+ // errors can prevent the corresponding mod->loaded = true;
+ mod->loaded = false;
// default model radius and bounding box (mainly for missing models)
mod->radius = 16;
else if (!memcmp(buf, "IDP2", 4)) Mod_IDP2_Load(mod, buf);
else if (!memcmp(buf, "IDP3", 4)) Mod_IDP3_Load(mod, buf);
else if (!memcmp(buf, "IDSP", 4)) Mod_IDSP_Load(mod, buf);
+ else if (!memcmp(buf, "IDS2", 4)) Mod_IDS2_Load(mod, buf);
else if (!memcmp(buf, "IBSP", 4)) Mod_IBSP_Load(mod, buf);
else if (!memcmp(buf, "ZYMOTICMODEL", 12)) Mod_ZYMOTICMODEL_Load(mod, buf);
else if (strlen(mod->name) >= 4 && !strcmp(mod->name - 4, ".map")) Mod_MAP_Load(mod, buf);
else if (crash)
{
// LordHavoc: Sys_Error was *ANNOYING*
- Con_Printf ("Mod_LoadModel: %s not found", mod->name);
+ Con_Printf ("Mod_LoadModel: %s not found\n", mod->name);
}
// no errors occurred
- mod->needload = false;
+ mod->loaded = true;
return mod;
}
{
if (mod)
{
- if (mod->needload)
+ if (!mod->loaded)
Mod_LoadModel(mod, true, true, mod->isworldmodel);
else
{
Mod_FreeModel(mod);
}
+// only used during loading!
+void Mod_RemoveStaleWorldModels(model_t *skip)
+{
+ int i;
+ for (i = 0;i < MAX_MOD_KNOWN;i++)
+ if (mod_known[i].isworldmodel && skip != &mod_known[i])
+ Mod_UnloadModel(mod_known + i);
+}
+
void Mod_LoadModels(void)
{
int i;
{
mod = freemod;
strcpy (mod->name, name);
- mod->needload = true;
+ mod->loaded = false;
mod->used = true;
return mod;
}
return NULL;
}
-/*
-==================
-Mod_TouchModel
-
-==================
-*/
-void Mod_TouchModel(const char *name)
-{
- model_t *mod;
-
- mod = Mod_FindName(name);
- mod->used = true;
-}
-
/*
==================
Mod_ForName
Con_Print("usage: modelprecache <filename>\n");
}
+int Mod_BuildVertexRemapTableFromElements(int numelements, const int *elements, int numvertices, int *remapvertices)
+{
+ int i, count;
+ qbyte *used;
+ used = Mem_Alloc(tempmempool, numvertices);
+ memset(used, 0, numvertices);
+ for (i = 0;i < numelements;i++)
+ used[elements[i]] = 1;
+ for (i = 0, count = 0;i < numvertices;i++)
+ remapvertices[i] = used[i] ? count++ : -1;
+ Mem_Free(used);
+ return count;
+}
+
#if 1
// fast way, using an edge hash
-#define TRIANGLEEDGEHASH 1024
+#define TRIANGLEEDGEHASH 16384
void Mod_BuildTriangleNeighbors(int *neighbors, const int *elements, int numtriangles)
{
int i, j, p, e1, e2, *n, hashindex, count, match;
Con_Printf("Mod_ValidateElements: out of bounds element detected at %s:%d\n", filename, fileline);
}
+// warning: this is an expensive function!
+void Mod_BuildNormals(int numverts, int numtriangles, const float *vertex3f, const int *elements, float *normal3f)
+{
+ int i, tnum;
+ float normal[3], *v;
+ const int *e;
+ // clear the vectors
+ memset(normal3f, 0, numverts * sizeof(float[3]));
+ // process each vertex of each triangle and accumulate the results
+ for (tnum = 0, e = elements;tnum < numtriangles;tnum++, e += 3)
+ {
+ TriangleNormal(vertex3f + e[0] * 3, vertex3f + e[1] * 3, vertex3f + e[2] * 3, normal);
+ VectorNormalize(normal);
+ v = normal3f + e[0] * 3;
+ v[0] += normal[0];
+ v[1] += normal[1];
+ v[2] += normal[2];
+ v = normal3f + e[1] * 3;
+ v[0] += normal[0];
+ v[1] += normal[1];
+ v[2] += normal[2];
+ v = normal3f + e[2] * 3;
+ v[0] += normal[0];
+ v[1] += normal[1];
+ v[2] += normal[2];
+ }
+ // now we could divide the vectors by the number of averaged values on
+ // each vertex... but instead normalize them
+ for (i = 0, v = normal3f;i < numverts;i++, v += 3)
+ VectorNormalize(v);
+}
+
void Mod_BuildBumpVectors(const float *v0, const float *v1, const float *v2, const float *tc0, const float *tc1, const float *tc2, float *svector3f, float *tvector3f, float *normal3f)
{
- float f, tangentcross[3];
- normal3f[0] = (v1[1] - v0[1]) * (v2[2] - v0[2]) - (v1[2] - v0[2]) * (v2[1] - v0[1]);
- normal3f[1] = (v1[2] - v0[2]) * (v2[0] - v0[0]) - (v1[0] - v0[0]) * (v2[2] - v0[2]);
- normal3f[2] = (v1[0] - v0[0]) * (v2[1] - v0[1]) - (v1[1] - v0[1]) * (v2[0] - v0[0]);
+ float f, tangentcross[3], v10[3], v20[3], tc10[2], tc20[2];
+ // 103 add/sub/negate/multiply (1 cycle), 3 divide (20 cycle), 3 sqrt (22 cycle), 4 compare (3 cycle?), total cycles not counting load/store/exchange roughly 241 cycles
+ // 12 add, 28 subtract, 57 multiply, 3 divide, 3 sqrt, 4 compare, 50% chance of 6 negates
+
+ // 6 multiply, 9 subtract
+ VectorSubtract(v1, v0, v10);
+ VectorSubtract(v2, v0, v20);
+ normal3f[0] = v10[1] * v20[2] - v10[2] * v20[1];
+ normal3f[1] = v10[2] * v20[0] - v10[0] * v20[2];
+ normal3f[2] = v10[0] * v20[1] - v10[1] * v20[0];
+ // 1 sqrt, 1 divide, 6 multiply, 2 add, 1 compare
VectorNormalize(normal3f);
- tvector3f[0] = ((tc1[0] - tc0[0]) * (v2[0] - v0[0]) - (tc2[0] - tc0[0]) * (v1[0] - v0[0]));
- tvector3f[1] = ((tc1[0] - tc0[0]) * (v2[1] - v0[1]) - (tc2[0] - tc0[0]) * (v1[1] - v0[1]));
- tvector3f[2] = ((tc1[0] - tc0[0]) * (v2[2] - v0[2]) - (tc2[0] - tc0[0]) * (v1[2] - v0[2]));
- f = -DotProduct(tvector3f, normal3f);
- VectorMA(tvector3f, f, normal3f, tvector3f);
- VectorNormalize(tvector3f);
- // note: can't be a CrossProduct as that sometimes flips the texture
- svector3f[0] = ((tc1[1] - tc0[1]) * (v2[0] - v0[0]) - (tc2[1] - tc0[1]) * (v1[0] - v0[0]));
- svector3f[1] = ((tc1[1] - tc0[1]) * (v2[1] - v0[1]) - (tc2[1] - tc0[1]) * (v1[1] - v0[1]));
- svector3f[2] = ((tc1[1] - tc0[1]) * (v2[2] - v0[2]) - (tc2[1] - tc0[1]) * (v1[2] - v0[2]));
- f = -DotProduct(svector3f, normal3f);
- VectorMA(svector3f, f, normal3f, svector3f);
+ // 12 multiply, 10 subtract
+ tc10[1] = tc1[1] - tc0[1];
+ tc20[1] = tc2[1] - tc0[1];
+ svector3f[0] = tc10[1] * v20[0] - tc20[1] * v10[0];
+ svector3f[1] = tc10[1] * v20[1] - tc20[1] * v10[1];
+ svector3f[2] = tc10[1] * v20[2] - tc20[1] * v10[2];
+ tc10[0] = tc1[0] - tc0[0];
+ tc20[0] = tc2[0] - tc0[0];
+ tvector3f[0] = tc10[0] * v20[0] - tc20[0] * v10[0];
+ tvector3f[1] = tc10[0] * v20[1] - tc20[0] * v10[1];
+ tvector3f[2] = tc10[0] * v20[2] - tc20[0] * v10[2];
+ // 12 multiply, 4 add, 6 subtract
+ f = DotProduct(svector3f, normal3f);
+ svector3f[0] -= f * normal3f[0];
+ svector3f[1] -= f * normal3f[1];
+ svector3f[2] -= f * normal3f[2];
+ f = DotProduct(tvector3f, normal3f);
+ tvector3f[0] -= f * normal3f[0];
+ tvector3f[1] -= f * normal3f[1];
+ tvector3f[2] -= f * normal3f[2];
+ // 2 sqrt, 2 divide, 12 multiply, 4 add, 2 compare
VectorNormalize(svector3f);
+ VectorNormalize(tvector3f);
+ // if texture is mapped the wrong way (counterclockwise), the tangents
+ // have to be flipped, this is detected by calculating a normal from the
+ // two tangents, and seeing if it is opposite the surface normal
+ // 9 multiply, 2 add, 3 subtract, 1 compare, 50% chance of: 6 negates
CrossProduct(tvector3f, svector3f, tangentcross);
- // if texture is mapped the wrong way (counterclockwise), the tangents have to be flipped, this is detected by calculating a normal from the two tangents, and seeing if it is opposite the surface normal
if (DotProduct(tangentcross, normal3f) < 0)
{
VectorNegate(svector3f, svector3f);
}
}
-// warning: this is an expensive function!
+// warning: this is a very expensive function!
void Mod_BuildTextureVectorsAndNormals(int numverts, int numtriangles, const float *vertex3f, const float *texcoord2f, const int *elements, float *svector3f, float *tvector3f, float *normal3f)
{
int i, tnum;
VectorNormalize(v);
}
+surfmesh_t *Mod_AllocSurfMesh(mempool_t *mempool, int numvertices, int numtriangles, qboolean detailtexcoords, qboolean lightmapoffsets, qboolean vertexcolors, qboolean neighbors)
+{
+ surfmesh_t *mesh;
+ qbyte *data;
+ mesh = Mem_Alloc(mempool, sizeof(surfmesh_t) + numvertices * (3 + 3 + 3 + 3 + 2 + 2 + (detailtexcoords ? 2 : 0) + (vertexcolors ? 4 : 0)) * sizeof(float) + numvertices * (lightmapoffsets ? 1 : 0) * sizeof(int) + numtriangles * (3 + (neighbors ? 3 : 0)) * sizeof(int));
+ mesh->num_vertices = numvertices;
+ mesh->num_triangles = numtriangles;
+ data = (qbyte *)(mesh + 1);
+ if (mesh->num_vertices)
+ {
+ mesh->data_vertex3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
+ mesh->data_svector3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
+ mesh->data_tvector3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
+ mesh->data_normal3f = (float *)data, data += sizeof(float[3]) * mesh->num_vertices;
+ mesh->data_texcoordtexture2f = (float *)data, data += sizeof(float[2]) * mesh->num_vertices;
+ mesh->data_texcoordlightmap2f = (float *)data, data += sizeof(float[2]) * mesh->num_vertices;
+ if (detailtexcoords)
+ mesh->data_texcoorddetail2f = (float *)data, data += sizeof(float[2]) * mesh->num_vertices;
+ if (vertexcolors)
+ mesh->data_lightmapcolor4f = (float *)data, data += sizeof(float[4]) * mesh->num_vertices;
+ if (lightmapoffsets)
+ mesh->data_lightmapoffsets = (int *)data, data += sizeof(int) * mesh->num_vertices;
+ }
+ if (mesh->num_triangles)
+ {
+ mesh->data_element3i = (int *)data, data += sizeof(int[3]) * mesh->num_triangles;
+ if (neighbors)
+ mesh->data_neighbor3i = (int *)data, data += sizeof(int[3]) * mesh->num_triangles;
+ }
+ return mesh;
+}
+
shadowmesh_t *Mod_ShadowMesh_Alloc(mempool_t *mempool, int maxverts, int maxtriangles, rtexture_t *map_diffuse, rtexture_t *map_specular, rtexture_t *map_normal, int light, int neighbors, int expandable)
{
shadowmesh_t *newmesh;
int i, words, numtags, line, tagsetsused = false, wordsoverflow;
char *text;
const char *data;
- skinfile_t *skinfile, *first = NULL;
+ skinfile_t *skinfile = NULL, *first = NULL;
skinfileitem_t *skinfileitem;
char word[10][MAX_QPATH];
overridetagnameset_t tagsets[MAX_SKINS];
for (i = 0;i < MAX_SKINS && (data = text = FS_LoadFile(va("%s_%i.skin", loadmodel->name, i), tempmempool, true));i++)
{
numtags = 0;
- skinfile = Mem_Alloc(tempmempool, sizeof(skinfile_t));
- skinfile->next = first;
- first = skinfile;
+
+ // If it's the first file we parse
+ if (skinfile == NULL)
+ {
+ skinfile = Mem_Alloc(tempmempool, sizeof(skinfile_t));
+ first = skinfile;
+ }
+ else
+ {
+ skinfile->next = Mem_Alloc(tempmempool, sizeof(skinfile_t));
+ skinfile = skinfile->next;
+ }
+ skinfile->next = NULL;
+
for(line = 0;;line++)
{
// parse line
return i;
}
+void Mod_SnapVertices(int numcomponents, int numvertices, float *vertices, float snap)
+{
+ int i;
+ double isnap = 1.0 / snap;
+ for (i = 0;i < numvertices*numcomponents;i++)
+ vertices[i] = floor(vertices[i]*isnap)*snap;
+}
+
int Mod_RemoveDegenerateTriangles(int numtriangles, const int *inelement3i, int *outelement3i, const float *vertex3f)
{
int i, outtriangles;
projects / xonotic / darkplaces.git / blobdiff