static void mod_start(void)
{
int i, count;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
SCR_PushLoadingScreen(false, "Loading models", 1.0);
static void mod_shutdown(void)
{
int i;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
for (i = 0;i < nummodels;i++)
{
msurface_t *surface;
int i, j, k, surfacenum, ssize, tsize;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
for (i = 0;i < nummodels;i++)
used = mod->used;
if (mod->mempool)
{
- if (mod->surfmesh.vertex3fbuffer)
- R_Mesh_DestroyMeshBuffer(mod->surfmesh.vertex3fbuffer);
- mod->surfmesh.vertex3fbuffer = NULL;
- if (mod->surfmesh.vertexmeshbuffer)
- R_Mesh_DestroyMeshBuffer(mod->surfmesh.vertexmeshbuffer);
- mod->surfmesh.vertexmeshbuffer = NULL;
if (mod->surfmesh.data_element3i_indexbuffer)
R_Mesh_DestroyMeshBuffer(mod->surfmesh.data_element3i_indexbuffer);
mod->surfmesh.data_element3i_indexbuffer = NULL;
mod->loaded = false;
}
-void R_Model_Null_Draw(entity_render_t *ent)
+static void R_Model_Null_Draw(entity_render_t *ent)
{
return;
}
-typedef void (*mod_framegroupify_parsegroups_t) (unsigned int i, int start, int len, float fps, qboolean loop, void *pass);
+typedef void (*mod_framegroupify_parsegroups_t) (unsigned int i, int start, int len, float fps, qboolean loop, const char *name, void *pass);
-int Mod_FrameGroupify_ParseGroups(const char *buf, mod_framegroupify_parsegroups_t cb, void *pass)
+static int Mod_FrameGroupify_ParseGroups(const char *buf, mod_framegroupify_parsegroups_t cb, void *pass)
{
const char *bufptr;
int start, len;
float fps;
unsigned int i;
qboolean loop;
+ char name[64];
bufptr = buf;
i = 0;
- for(;;)
+ while(bufptr)
{
// an anim scene!
- if (!COM_ParseToken_Simple(&bufptr, true, false))
- break;
+
+ // REQUIRED: fetch start
+ COM_ParseToken_Simple(&bufptr, true, false, true);
+ if (!bufptr)
+ break; // end of file
if (!strcmp(com_token, "\n"))
continue; // empty line
start = atoi(com_token);
- if (!COM_ParseToken_Simple(&bufptr, true, false))
- break;
- if (!strcmp(com_token, "\n"))
+
+ // REQUIRED: fetch length
+ COM_ParseToken_Simple(&bufptr, true, false, true);
+ if (!bufptr || !strcmp(com_token, "\n"))
{
Con_Printf("framegroups file: missing number of frames\n");
continue;
}
len = atoi(com_token);
- if (!COM_ParseToken_Simple(&bufptr, true, false))
- break;
- // we default to looping as it's usually wanted, so to NOT loop you append a 0
- if (strcmp(com_token, "\n"))
+
+ // OPTIONAL args start
+ COM_ParseToken_Simple(&bufptr, true, false, true);
+
+ // OPTIONAL: fetch fps
+ fps = 20;
+ if (bufptr && strcmp(com_token, "\n"))
{
fps = atof(com_token);
- if (!COM_ParseToken_Simple(&bufptr, true, false))
- break;
- if (strcmp(com_token, "\n"))
- loop = atoi(com_token) != 0;
- else
- loop = true;
+ COM_ParseToken_Simple(&bufptr, true, false, true);
}
- else
+
+ // OPTIONAL: fetch loopflag
+ loop = true;
+ if (bufptr && strcmp(com_token, "\n"))
{
- fps = 20;
- loop = true;
+ loop = (atoi(com_token) != 0);
+ COM_ParseToken_Simple(&bufptr, true, false, true);
}
+ // OPTIONAL: fetch name
+ name[0] = 0;
+ if (bufptr && strcmp(com_token, "\n"))
+ {
+ strlcpy(name, com_token, sizeof(name));
+ COM_ParseToken_Simple(&bufptr, true, false, true);
+ }
+
+ // OPTIONAL: remaining unsupported tokens (eat them)
+ while (bufptr && strcmp(com_token, "\n"))
+ COM_ParseToken_Simple(&bufptr, true, false, true);
+
+ //Con_Printf("data: %d %d %d %f %d (%s)\n", i, start, len, fps, loop, name);
+
if(cb)
- cb(i, start, len, fps, loop, pass);
+ cb(i, start, len, fps, loop, (name[0] ? name : NULL), pass);
++i;
}
return i;
}
-void Mod_FrameGroupify_ParseGroups_Count (unsigned int i, int start, int len, float fps, qboolean loop, void *pass)
-{
- unsigned int *cnt = (unsigned int *) pass;
- ++*cnt;
-}
-
-void Mod_FrameGroupify_ParseGroups_Store (unsigned int i, int start, int len, float fps, qboolean loop, void *pass)
+static void Mod_FrameGroupify_ParseGroups_Store (unsigned int i, int start, int len, float fps, qboolean loop, const char *name, void *pass)
{
dp_model_t *mod = (dp_model_t *) pass;
animscene_t *anim = &mod->animscenes[i];
- dpsnprintf(anim->name, sizeof(anim[i].name), "groupified_%d_anim", i);
+ if(name)
+ strlcpy(anim->name, name, sizeof(anim[i].name));
+ else
+ dpsnprintf(anim->name, sizeof(anim[i].name), "groupified_%d_anim", i);
anim->firstframe = bound(0, start, mod->num_poses - 1);
anim->framecount = bound(1, len, mod->num_poses - anim->firstframe);
anim->framerate = max(1, fps);
//Con_Printf("frame group %d is %d %d %f %d\n", i, start, len, fps, loop);
}
-void Mod_FrameGroupify(dp_model_t *mod, const char *buf)
+static void Mod_FrameGroupify(dp_model_t *mod, const char *buf)
{
unsigned int cnt;
Mod_FrameGroupify_ParseGroups(buf, Mod_FrameGroupify_ParseGroups_Store, mod);
}
-void Mod_FindPotentialDeforms(dp_model_t *mod)
+static void Mod_FindPotentialDeforms(dp_model_t *mod)
{
int i, j;
texture_t *texture;
unsigned int crc;
void *buf;
fs_offset_t filesize = 0;
+ char vabuf[1024];
mod->used = true;
// errors can prevent the corresponding mod->loaded = true;
mod->loaded = false;
+ // default lightmap scale
+ mod->lightmapscale = 1;
+
// default model radius and bounding box (mainly for missing models)
mod->radius = 16;
VectorSet(mod->normalmins, -mod->radius, -mod->radius, -mod->radius);
else if (!memcmp(buf, "ACTRHEAD", 8)) Mod_PSKMODEL_Load(mod, buf, bufend);
else if (!memcmp(buf, "INTERQUAKEMODEL", 16)) Mod_INTERQUAKEMODEL_Load(mod, buf, bufend);
else if (strlen(mod->name) >= 4 && !strcmp(mod->name + strlen(mod->name) - 4, ".map")) Mod_MAP_Load(mod, buf, bufend);
- else if (num == BSPVERSION || num == 30) Mod_Q1BSP_Load(mod, buf, bufend);
+ else if (num == BSPVERSION || num == 30 || !memcmp(buf, "BSP2", 4) || !memcmp(buf, "2PSB", 4)) Mod_Q1BSP_Load(mod, buf, bufend);
else Con_Printf("Mod_LoadModel: model \"%s\" is of unknown/unsupported type\n", mod->name);
Mem_Free(buf);
Mod_FindPotentialDeforms(mod);
-
- buf = FS_LoadFile (va("%s.framegroups", mod->name), tempmempool, false, &filesize);
+
+ buf = FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.framegroups", mod->name), tempmempool, false, &filesize);
if(buf)
{
Mod_FrameGroupify(mod, (const char *)buf);
void Mod_ClearUsed(void)
{
int i;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
for (i = 0;i < nummodels;i++)
if ((mod = (dp_model_t*) Mem_ExpandableArray_RecordAtIndex(&models, i)) && mod->name[0])
void Mod_PurgeUnused(void)
{
int i;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
for (i = 0;i < nummodels;i++)
{
// if we're not dedicatd, the renderer calls will crash without video
Host_StartVideo();
- nummodels = Mem_ExpandableArray_IndexRange(&models);
+ nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
if (!name[0])
- Host_Error ("Mod_ForName: NULL name");
+ Host_Error ("Mod_ForName: empty name");
// search the currently loaded models
for (i = 0;i < nummodels;i++)
void Mod_Reload(void)
{
int i, count;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
SCR_PushLoadingScreen(false, "Reloading models", 1.0);
static void Mod_Print(void)
{
int i;
- int nummodels = Mem_ExpandableArray_IndexRange(&models);
+ int nummodels = (int)Mem_ExpandableArray_IndexRange(&models);
dp_model_t *mod;
Con_Print("Loaded models:\n");
VectorNormalize(vectorNormal);
}
-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)
+#if 0
+static 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], v10[3], v20[3], tc10[2], tc20[2];
// 79 add/sub/negate/multiply (1 cycle), 1 compare (3 cycle?), total cycles not counting load/store/exchange roughly 82 cycles
VectorNegate(tvector3f, tvector3f);
}
}
+#endif
// warning: this is a very expensive function!
void Mod_BuildTextureVectorsFromNormals(int firstvertex, int numvertices, int numtriangles, const float *vertex3f, const float *texcoord2f, const float *normal3f, const int *elements, float *svector3f, float *tvector3f, qboolean areaweighting)
}
}
- // upload r_vertexmesh_t array as a buffer
- if (mesh->vertexmesh && !mesh->vertexmeshbuffer)
- mesh->vertexmeshbuffer = R_Mesh_CreateMeshBuffer(mesh->vertexmesh, mesh->numverts * sizeof(*mesh->vertexmesh), loadmodel->name, false, false, false);
-
- // upload vertex3f array as a buffer
- if (mesh->vertex3f && !mesh->vertex3fbuffer)
- mesh->vertex3fbuffer = R_Mesh_CreateMeshBuffer(mesh->vertex3f, mesh->numverts * sizeof(float[3]), loadmodel->name, false, false, false);
-
// upload short indices as a buffer
if (mesh->element3s && !mesh->element3s_indexbuffer)
- mesh->element3s_indexbuffer = R_Mesh_CreateMeshBuffer(mesh->element3s, mesh->numtriangles * sizeof(short[3]), loadmodel->name, true, false, true);
+ mesh->element3s_indexbuffer = R_Mesh_CreateMeshBuffer(mesh->element3s, mesh->numtriangles * sizeof(short[3]), loadmodel->name, true, false, false, true);
// upload int indices as a buffer
if (mesh->element3i && !mesh->element3i_indexbuffer && !mesh->element3s)
- mesh->element3i_indexbuffer = R_Mesh_CreateMeshBuffer(mesh->element3i, mesh->numtriangles * sizeof(int[3]), loadmodel->name, true, false, false);
+ mesh->element3i_indexbuffer = R_Mesh_CreateMeshBuffer(mesh->element3i, mesh->numtriangles * sizeof(int[3]), loadmodel->name, true, false, false, false);
// vertex buffer is several arrays and we put them in the same buffer
//
// other hand animated models don't use a lot of vertices anyway...
if (!mesh->vbo_vertexbuffer && !vid.useinterleavedarrays)
{
- size_t size;
+ int size;
unsigned char *mem;
size = 0;
+ mesh->vbooffset_vertexmesh = size;if (mesh->vertexmesh ) size += mesh->numverts * sizeof(r_vertexmesh_t);
mesh->vbooffset_vertex3f = size;if (mesh->vertex3f ) size += mesh->numverts * sizeof(float[3]);
mesh->vbooffset_svector3f = size;if (mesh->svector3f ) size += mesh->numverts * sizeof(float[3]);
mesh->vbooffset_tvector3f = size;if (mesh->tvector3f ) size += mesh->numverts * sizeof(float[3]);
mesh->vbooffset_normal3f = size;if (mesh->normal3f ) size += mesh->numverts * sizeof(float[3]);
mesh->vbooffset_texcoord2f = size;if (mesh->texcoord2f ) size += mesh->numverts * sizeof(float[2]);
mem = (unsigned char *)Mem_Alloc(tempmempool, size);
+ if (mesh->vertexmesh ) memcpy(mem + mesh->vbooffset_vertexmesh , mesh->vertexmesh , mesh->numverts * sizeof(r_vertexmesh_t));
if (mesh->vertex3f ) memcpy(mem + mesh->vbooffset_vertex3f , mesh->vertex3f , mesh->numverts * sizeof(float[3]));
if (mesh->svector3f ) memcpy(mem + mesh->vbooffset_svector3f , mesh->svector3f , mesh->numverts * sizeof(float[3]));
if (mesh->tvector3f ) memcpy(mem + mesh->vbooffset_tvector3f , mesh->tvector3f , mesh->numverts * sizeof(float[3]));
if (mesh->normal3f ) memcpy(mem + mesh->vbooffset_normal3f , mesh->normal3f , mesh->numverts * sizeof(float[3]));
if (mesh->texcoord2f ) memcpy(mem + mesh->vbooffset_texcoord2f , mesh->texcoord2f , mesh->numverts * sizeof(float[2]));
- mesh->vbo_vertexbuffer = R_Mesh_CreateMeshBuffer(mem, size, "shadowmesh", false, false, false);
+ mesh->vbo_vertexbuffer = R_Mesh_CreateMeshBuffer(mem, size, "shadowmesh", false, false, false, false);
Mem_Free(mem);
}
}
shadowmesh_t *nextmesh;
for (;mesh;mesh = nextmesh)
{
- if (mesh->vertex3fbuffer)
- R_Mesh_DestroyMeshBuffer(mesh->vertex3fbuffer);
- if (mesh->vertexmeshbuffer)
- R_Mesh_DestroyMeshBuffer(mesh->vertexmeshbuffer);
if (mesh->element3i_indexbuffer)
R_Mesh_DestroyMeshBuffer(mesh->element3i_indexbuffer);
if (mesh->element3s_indexbuffer)
for (k = 0;k < mod->nummodelsurfaces;k++)
{
surface = mod->data_surfaces + mod->firstmodelsurface + k;
- if (!strcmp(surface->texture->name, "collision")) // found collision mesh
+ if (!strcmp(surface->texture->name, "collision") || !strcmp(surface->texture->name, "collisionconvex")) // found collision mesh
{
usesinglecollisionmesh = true;
numcollisionmeshtriangles = surface->num_triangles;
mod->brush.collisionmesh = Mod_ShadowMesh_Finish(mempool, mod->brush.collisionmesh, false, false, false);
}
-void Mod_GetTerrainVertex3fTexCoord2fFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+#if 0
+static void Mod_GetTerrainVertex3fTexCoord2fFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
{
float v[3], tc[3];
v[0] = ix;
texcoord2f[1] = tc[1];
}
-void Mod_GetTerrainVertexFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+static void Mod_GetTerrainVertexFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int ix, int iy, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
{
float vup[3], vdown[3], vleft[3], vright[3];
float tcup[3], tcdown[3], tcleft[3], tcright[3];
VectorAdd(normal3f, nl, normal3f);
}
-void Mod_ConstructTerrainPatchFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int x1, int y1, int width, int height, int *element3i, int *neighbor3i, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
+static void Mod_ConstructTerrainPatchFromBGRA(const unsigned char *imagepixels, int imagewidth, int imageheight, int x1, int y1, int width, int height, int *element3i, int *neighbor3i, float *vertex3f, float *svector3f, float *tvector3f, float *normal3f, float *texcoord2f, matrix4x4_t *pixelstepmatrix, matrix4x4_t *pixeltexturestepmatrix)
{
int x, y, ix, iy, *e;
e = element3i;
for (x = 0, ix = x1;x < width + 1;x++, ix++, vertex3f += 3, texcoord2f += 2, svector3f += 3, tvector3f += 3, normal3f += 3)
Mod_GetTerrainVertexFromBGRA(imagepixels, imagewidth, imageheight, ix, iy, vertex3f, texcoord2f, svector3f, tvector3f, normal3f, pixelstepmatrix, pixeltexturestepmatrix);
}
+#endif
#if 0
void Mod_Terrain_SurfaceRecurseChunk(dp_model_t *model, int stepsize, int x, int y)
}
#endif
-int Mod_LoadQ3Shaders_EnumerateWaveFunc(const char *s)
+static int Mod_LoadQ3Shaders_EnumerateWaveFunc(const char *s)
{
int offset = 0;
if (!strncasecmp(s, "user", 4)) // parse stuff like "user1sin", always user<n>func
unsigned short hash = CRC_Block_CaseInsensitive ((const unsigned char *)shader->name, strlen (shader->name));
q3shader_hash_entry_t* entry = q3shader_data->hash + (hash % Q3SHADER_HASH_SIZE);
q3shader_hash_entry_t* lastEntry = NULL;
- while (entry != NULL)
+ do
{
if (strcasecmp (entry->shader.name, shader->name) == 0)
{
lastEntry = entry;
entry = entry->chain;
}
+ while (entry != NULL);
if (entry == NULL)
{
if (lastEntry->shader.name[0] != 0)
extern cvar_t mod_noshader_default_offsetmapping;
extern cvar_t mod_q3shader_default_offsetmapping;
+extern cvar_t mod_q3shader_default_offsetmapping_scale;
extern cvar_t mod_q3shader_default_offsetmapping_bias;
extern cvar_t mod_q3shader_default_polygonoffset;
extern cvar_t mod_q3shader_default_polygonfactor;
+extern cvar_t mod_q3shader_force_addalpha;
+extern cvar_t mod_q3shader_force_terrain_alphaflag;
void Mod_LoadQ3Shaders(void)
{
int j;
int numparameters;
char parameter[TEXTURE_MAXFRAMES + 4][Q3PATHLENGTH];
char *custsurfaceparmnames[256]; // VorteX: q3map2 has 64 but well, someone will need more
- unsigned long custsurfaceparms[256];
- int numcustsurfaceparms;
+ unsigned long custsurfaceflags[256];
+ int numcustsurfaceflags;
qboolean dpshaderkill;
Mod_FreeQ3Shaders();
q3shaders_mem, sizeof (char**), 256);
// parse custinfoparms.txt
- numcustsurfaceparms = 0;
+ numcustsurfaceflags = 0;
if ((text = f = (char *)FS_LoadFile("scripts/custinfoparms.txt", tempmempool, false, NULL)) != NULL)
{
if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
if (!strcasecmp(com_token, "}"))
break;
// register surfaceflag
- if (numcustsurfaceparms >= 256)
+ if (numcustsurfaceflags >= 256)
{
Con_Printf("scripts/custinfoparms.txt: surfaceflags section parsing error - max 256 surfaceflags exceeded\n");
break;
}
// name
- j = strlen(com_token)+1;
- custsurfaceparmnames[numcustsurfaceparms] = (char *)Mem_Alloc(tempmempool, j);
- strlcpy(custsurfaceparmnames[numcustsurfaceparms], com_token, j+1);
+ j = (int)strlen(com_token)+1;
+ custsurfaceparmnames[numcustsurfaceflags] = (char *)Mem_Alloc(tempmempool, j);
+ strlcpy(custsurfaceparmnames[numcustsurfaceflags], com_token, j+1);
// value
if (COM_ParseToken_QuakeC(&text, false))
- custsurfaceparms[numcustsurfaceparms] = strtol(com_token, NULL, 0);
+ custsurfaceflags[numcustsurfaceflags] = strtol(com_token, NULL, 0);
else
- custsurfaceparms[numcustsurfaceparms] = 0;
- numcustsurfaceparms++;
+ custsurfaceflags[numcustsurfaceflags] = 0;
+ numcustsurfaceflags++;
}
}
}
while (COM_ParseToken_QuakeC(&text, false))
{
memset (&shader, 0, sizeof(shader));
+ shader.name[0] = 0;
+ shader.surfaceparms = 0;
+ shader.surfaceflags = 0;
+ shader.textureflags = 0;
+ shader.numlayers = 0;
+ shader.lighting = false;
+ shader.vertexalpha = false;
+ shader.textureblendalpha = false;
+ shader.primarylayer = 0;
+ shader.backgroundlayer = 0;
+ shader.skyboxname[0] = 0;
+ shader.deforms[0].deform = Q3DEFORM_NONE;
+ shader.dpnortlight = false;
+ shader.dpshadow = false;
+ shader.dpnoshadow = false;
+ shader.dpmeshcollisions = false;
+ shader.dpshaderkill = false;
+ shader.dpreflectcube[0] = 0;
shader.reflectmin = 0;
shader.reflectmax = 1;
shader.refractfactor = 1;
shader.reflectfactor = 1;
Vector4Set(shader.reflectcolor4f, 1, 1, 1, 1);
shader.r_water_wateralpha = 1;
+ shader.r_water_waterscroll[0] = 0;
+ shader.r_water_waterscroll[1] = 0;
shader.offsetmapping = (mod_q3shader_default_offsetmapping.value) ? OFFSETMAPPING_DEFAULT : OFFSETMAPPING_OFF;
- shader.offsetscale = 1;
- shader.offsetbias = bound(0, mod_q3shader_default_offsetmapping_bias.integer, 255);
- shader.specularscalemod = 1;
- shader.specularpowermod = 1;
+ shader.offsetscale = mod_q3shader_default_offsetmapping_scale.value;
+ shader.offsetbias = mod_q3shader_default_offsetmapping_bias.value;
shader.biaspolygonoffset = mod_q3shader_default_polygonoffset.value;
shader.biaspolygonfactor = mod_q3shader_default_polygonfactor.value;
+ shader.transparentsort = TRANSPARENTSORT_DISTANCE;
+ shader.specularscalemod = 1;
+ shader.specularpowermod = 1;
+ shader.rtlightambient = 0;
+ // WHEN ADDING DEFAULTS HERE, REMEMBER TO PUT DEFAULTS IN ALL LOADERS
+ // JUST GREP FOR "specularscalemod = 1".
strlcpy(shader.name, com_token, sizeof(shader.name));
if (!COM_ParseToken_QuakeC(&text, false) || strcasecmp(com_token, "{"))
layer->blendfunc[0] = GL_ONE;
layer->blendfunc[1] = GL_ONE;
}
+ else if (!strcasecmp(parameter[1], "addalpha"))
+ {
+ layer->blendfunc[0] = GL_SRC_ALPHA;
+ layer->blendfunc[1] = GL_ONE;
+ }
else if (!strcasecmp(parameter[1], "filter"))
{
layer->blendfunc[0] = GL_DST_COLOR;
else if (!strcasecmp(parameter[k+1], "GL_DST_COLOR"))
layer->blendfunc[k] = GL_DST_COLOR;
else if (!strcasecmp(parameter[k+1], "GL_DST_ALPHA"))
- layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
+ layer->blendfunc[k] = GL_DST_ALPHA;
else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_COLOR"))
layer->blendfunc[k] = GL_ONE_MINUS_SRC_COLOR;
else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_ALPHA"))
{
// multilayer terrain shader or similar
shader.textureblendalpha = true;
+ if (mod_q3shader_force_terrain_alphaflag.integer)
+ shader.layers[0].texflags |= TEXF_ALPHA;
}
}
- layer->texflags = TEXF_ALPHA;
+
+ if(mod_q3shader_force_addalpha.integer)
+ {
+ // for a long while, DP treated GL_ONE GL_ONE as GL_SRC_ALPHA GL_ONE
+ // this cvar brings back this behaviour
+ if(layer->blendfunc[0] == GL_ONE && layer->blendfunc[1] == GL_ONE)
+ layer->blendfunc[0] = GL_SRC_ALPHA;
+ }
+
+ layer->texflags = 0;
+ if (layer->alphatest)
+ layer->texflags |= TEXF_ALPHA;
+ switch(layer->blendfunc[0])
+ {
+ case GL_SRC_ALPHA:
+ case GL_ONE_MINUS_SRC_ALPHA:
+ layer->texflags |= TEXF_ALPHA;
+ break;
+ }
+ switch(layer->blendfunc[1])
+ {
+ case GL_SRC_ALPHA:
+ case GL_ONE_MINUS_SRC_ALPHA:
+ layer->texflags |= TEXF_ALPHA;
+ break;
+ }
if (!(shader.surfaceparms & Q3SURFACEPARM_NOMIPMAPS))
layer->texflags |= TEXF_MIPMAP;
if (!(shader.textureflags & Q3TEXTUREFLAG_NOPICMIP))
shader.surfaceparms |= Q3SURFACEPARM_POINTLIGHT;
else if (!strcasecmp(parameter[1], "antiportal"))
shader.surfaceparms |= Q3SURFACEPARM_ANTIPORTAL;
+ else if (!strcasecmp(parameter[1], "skip"))
+ ; // shader.surfaceparms |= Q3SURFACEPARM_SKIP; FIXME we don't have enough #defines for this any more, and the engine doesn't need this one anyway
else
{
// try custom surfaceparms
- for (j = 0; j < numcustsurfaceparms; j++)
+ for (j = 0; j < numcustsurfaceflags; j++)
{
if (!strcasecmp(custsurfaceparmnames[j], parameter[1]))
{
- shader.surfaceparms |= custsurfaceparms[j];
+ shader.surfaceflags |= custsurfaceflags[j];
break;
}
}
// failed all
- if (j == numcustsurfaceparms)
+ if (j == numcustsurfaceflags)
Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]);
}
}
shader.biaspolygonoffset = 0;
}
}
+ else if (!strcasecmp(parameter[0], "dptransparentsort") && numparameters >= 2)
+ {
+ shader.textureflags |= Q3TEXTUREFLAG_TRANSPARENTSORT;
+ if (!strcasecmp(parameter[1], "sky"))
+ shader.transparentsort = TRANSPARENTSORT_SKY;
+ else if (!strcasecmp(parameter[1], "distance"))
+ shader.transparentsort = TRANSPARENTSORT_DISTANCE;
+ else if (!strcasecmp(parameter[1], "hud"))
+ shader.transparentsort = TRANSPARENTSORT_HUD;
+ else
+ Con_DPrintf("%s parsing warning: unknown dptransparentsort category \"%s\", or not enough arguments\n", search->filenames[fileindex], parameter[1]);
+ }
else if (!strcasecmp(parameter[0], "dprefract") && numparameters >= 5)
{
shader.textureflags |= Q3TEXTUREFLAG_REFRACTION;
shader.offsetmapping = OFFSETMAPPING_RELIEF;
if (numparameters >= 3)
shader.offsetscale = atof(parameter[2]);
- if (numparameters >= 4)
- shader.offsetbias = bound(0, atoi(parameter[3]), 255);
+ if (numparameters >= 5)
+ {
+ if(!strcasecmp(parameter[3], "bias"))
+ shader.offsetbias = atof(parameter[4]);
+ else if(!strcasecmp(parameter[3], "match"))
+ shader.offsetbias = 1.0f - atof(parameter[4]);
+ else if(!strcasecmp(parameter[3], "match8"))
+ shader.offsetbias = 1.0f - atof(parameter[4]) / 255.0f;
+ else if(!strcasecmp(parameter[3], "match16"))
+ shader.offsetbias = 1.0f - atof(parameter[4]) / 65535.0f;
+ }
}
else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
{
}
FS_FreeSearch(search);
// free custinfoparm values
- for (j = 0; j < numcustsurfaceparms; j++)
+ for (j = 0; j < numcustsurfaceflags; j++)
Mem_Free(custsurfaceparmnames[j]);
}
if (!name)
name = "";
strlcpy(texture->name, name, sizeof(texture->name));
+ texture->basealpha = 1.0f;
shader = name[0] ? Mod_LookupQ3Shader(name) : NULL;
texflagsmask = ~0;
texture->specularscalemod = 1;
texture->specularpowermod = 1;
texture->rtlightambient = 0;
- // WHEN ADDING DEFAULTS HERE, REMEMBER TO SYNC TO SHADER LOADING ABOVE
- // HERE, AND Q1BSP LOADING
+ texture->transparentsort = TRANSPARENTSORT_DISTANCE;
+ // WHEN ADDING DEFAULTS HERE, REMEMBER TO PUT DEFAULTS IN ALL LOADERS
// JUST GREP FOR "specularscalemod = 1".
if (shader)
{
if (developer_loading.integer)
Con_Printf("%s: loaded shader for %s\n", loadmodel->name, name);
- texture->surfaceparms = shader->surfaceparms;
// allow disabling of picmip or compression by defaulttexflags
texture->textureflags = (shader->textureflags & texflagsmask) | texflagsor;
texture->basematerialflags |= MATERIALFLAG_CAMERA;
texture->customblendfunc[0] = GL_ONE;
texture->customblendfunc[1] = GL_ZERO;
+ texture->transparentsort = shader->transparentsort;
if (shader->numlayers > 0)
{
texture->customblendfunc[0] = shader->layers[0].blendfunc[0];
texture->basematerialflags |= MATERIALFLAG_NOSHADOW;
if (shader->dpnortlight)
texture->basematerialflags |= MATERIALFLAG_NORTLIGHT;
+ if (shader->vertexalpha)
+ texture->basematerialflags |= MATERIALFLAG_ALPHAGEN_VERTEX;
memcpy(texture->deforms, shader->deforms, sizeof(texture->deforms));
texture->reflectmin = shader->reflectmin;
texture->reflectmax = shader->reflectmax;
// if (shader->surfaceparms & Q3SURFACEPARM_LIGHTGRID ) texture->supercontents |= SUPERCONTENTS_LIGHTGRID ;
// if (shader->surfaceparms & Q3SURFACEPARM_ANTIPORTAL ) texture->supercontents |= SUPERCONTENTS_ANTIPORTAL ;
+ texture->surfaceflags = shader->surfaceflags;
+ if (shader->surfaceparms & Q3SURFACEPARM_ALPHASHADOW ) texture->surfaceflags |= Q3SURFACEFLAG_ALPHASHADOW ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_AREAPORTAL ) texture->surfaceflags |= Q3SURFACEFLAG_AREAPORTAL ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_CLUSTERPORTAL) texture->surfaceflags |= Q3SURFACEFLAG_CLUSTERPORTAL;
+ // if (shader->surfaceparms & Q3SURFACEPARM_DETAIL ) texture->surfaceflags |= Q3SURFACEFLAG_DETAIL ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_DONOTENTER ) texture->surfaceflags |= Q3SURFACEFLAG_DONOTENTER ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_FOG ) texture->surfaceflags |= Q3SURFACEFLAG_FOG ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_LAVA ) texture->surfaceflags |= Q3SURFACEFLAG_LAVA ;
+ if (shader->surfaceparms & Q3SURFACEPARM_LIGHTFILTER ) texture->surfaceflags |= Q3SURFACEFLAG_LIGHTFILTER ;
+ if (shader->surfaceparms & Q3SURFACEPARM_METALSTEPS ) texture->surfaceflags |= Q3SURFACEFLAG_METALSTEPS ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NODAMAGE ) texture->surfaceflags |= Q3SURFACEFLAG_NODAMAGE ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NODLIGHT ) texture->surfaceflags |= Q3SURFACEFLAG_NODLIGHT ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NODRAW ) texture->surfaceflags |= Q3SURFACEFLAG_NODRAW ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_NODROP ) texture->surfaceflags |= Q3SURFACEFLAG_NODROP ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NOIMPACT ) texture->surfaceflags |= Q3SURFACEFLAG_NOIMPACT ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NOLIGHTMAP ) texture->surfaceflags |= Q3SURFACEFLAG_NOLIGHTMAP ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NOMARKS ) texture->surfaceflags |= Q3SURFACEFLAG_NOMARKS ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS ) texture->surfaceflags |= Q3SURFACEFLAG_NOMIPMAPS ;
+ if (shader->surfaceparms & Q3SURFACEPARM_NONSOLID ) texture->surfaceflags |= Q3SURFACEFLAG_NONSOLID ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_ORIGIN ) texture->surfaceflags |= Q3SURFACEFLAG_ORIGIN ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_PLAYERCLIP ) texture->surfaceflags |= Q3SURFACEFLAG_PLAYERCLIP ;
+ if (shader->surfaceparms & Q3SURFACEPARM_SKY ) texture->surfaceflags |= Q3SURFACEFLAG_SKY ;
+ if (shader->surfaceparms & Q3SURFACEPARM_SLICK ) texture->surfaceflags |= Q3SURFACEFLAG_SLICK ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_SLIME ) texture->surfaceflags |= Q3SURFACEFLAG_SLIME ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_STRUCTURAL ) texture->surfaceflags |= Q3SURFACEFLAG_STRUCTURAL ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_TRANS ) texture->surfaceflags |= Q3SURFACEFLAG_TRANS ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_WATER ) texture->surfaceflags |= Q3SURFACEFLAG_WATER ;
+ if (shader->surfaceparms & Q3SURFACEPARM_POINTLIGHT ) texture->surfaceflags |= Q3SURFACEFLAG_POINTLIGHT ;
+ if (shader->surfaceparms & Q3SURFACEPARM_HINT ) texture->surfaceflags |= Q3SURFACEFLAG_HINT ;
+ if (shader->surfaceparms & Q3SURFACEPARM_DUST ) texture->surfaceflags |= Q3SURFACEFLAG_DUST ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_BOTCLIP ) texture->surfaceflags |= Q3SURFACEFLAG_BOTCLIP ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_LIGHTGRID ) texture->surfaceflags |= Q3SURFACEFLAG_LIGHTGRID ;
+ // if (shader->surfaceparms & Q3SURFACEPARM_ANTIPORTAL ) texture->surfaceflags |= Q3SURFACEFLAG_ANTIPORTAL ;
+
if (shader->dpmeshcollisions)
texture->basematerialflags |= MATERIALFLAG_MESHCOLLISIONS;
if (shader->dpshaderkill && developer_extra.integer)
{
if (developer_extra.integer)
Con_DPrintf("^1%s:^7 using fallback noshader material for ^3\"%s\"\n", loadmodel->name, name);
- texture->surfaceparms = 0;
texture->supercontents = SUPERCONTENTS_SOLID | SUPERCONTENTS_OPAQUE;
}
else if (!strcmp(texture->name, "common/nodraw") || !strcmp(texture->name, "textures/common/nodraw"))
{
if (developer_extra.integer)
Con_DPrintf("^1%s:^7 using fallback nodraw material for ^3\"%s\"\n", loadmodel->name, name);
- texture->surfaceparms = 0;
texture->basematerialflags = MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
texture->supercontents = SUPERCONTENTS_SOLID;
}
{
if (developer_extra.integer)
Con_DPrintf("^1%s:^7 No shader found for texture ^3\"%s\"\n", loadmodel->name, texture->name);
- texture->surfaceparms = 0;
if (texture->surfaceflags & Q3SURFACEFLAG_NODRAW)
{
texture->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
{
if(texture->skinframes[0]->hasalpha)
texture->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
+ if (texture->q2contents)
+ texture->supercontents = Mod_Q2BSP_SuperContentsFromNativeContents(loadmodel, texture->q2contents);
}
else
success = false;
skinfile_t *skinfile = NULL, *first = NULL;
skinfileitem_t *skinfileitem;
char word[10][MAX_QPATH];
+ char vabuf[1024];
/*
sample file:
tag_torso,
*/
memset(word, 0, sizeof(word));
- for (i = 0;i < 256 && (data = text = (char *)FS_LoadFile(va("%s_%i.skin", loadmodel->name, i), tempmempool, true, NULL));i++)
+ for (i = 0;i < 256 && (data = text = (char *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s_%i.skin", loadmodel->name, i), tempmempool, true, NULL));i++)
{
// If it's the first file we parse
if (skinfile == NULL)
// build r_vertexmesh_t array
// (compressed interleaved array for D3D)
- if (!loadmodel->surfmesh.vertexmesh && vid.useinterleavedarrays)
+ if (!loadmodel->surfmesh.data_vertexmesh && vid.useinterleavedarrays)
{
int vertexindex;
int numvertices = loadmodel->surfmesh.num_vertices;
r_vertexmesh_t *vertexmesh;
- loadmodel->surfmesh.vertexmesh = vertexmesh = (r_vertexmesh_t*)Mem_Alloc(loadmodel->mempool, numvertices * sizeof(*loadmodel->surfmesh.vertexmesh));
+ loadmodel->surfmesh.data_vertexmesh = vertexmesh = (r_vertexmesh_t*)Mem_Alloc(loadmodel->mempool, numvertices * sizeof(r_vertexmesh_t));
for (vertexindex = 0;vertexindex < numvertices;vertexindex++, vertexmesh++)
{
VectorCopy(loadmodel->surfmesh.data_vertex3f + 3*vertexindex, vertexmesh->vertex3f);
Vector2Copy(loadmodel->surfmesh.data_texcoordtexture2f + 2*vertexindex, vertexmesh->texcoordtexture2f);
if (loadmodel->surfmesh.data_texcoordlightmap2f)
Vector2Scale(loadmodel->surfmesh.data_texcoordlightmap2f + 2*vertexindex, 1.0f, vertexmesh->texcoordlightmap2f);
+ if (loadmodel->surfmesh.data_skeletalindex4ub)
+ Vector4Copy(loadmodel->surfmesh.data_skeletalindex4ub + 4*vertexindex, vertexmesh->skeletalindex4ub);
+ if (loadmodel->surfmesh.data_skeletalweight4ub)
+ Vector4Copy(loadmodel->surfmesh.data_skeletalweight4ub + 4*vertexindex, vertexmesh->skeletalweight4ub);
}
}
- // upload r_vertexmesh_t array as a buffer
- if (loadmodel->surfmesh.vertexmesh && !loadmodel->surfmesh.vertexmeshbuffer)
- loadmodel->surfmesh.vertexmeshbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.vertexmesh, loadmodel->surfmesh.num_vertices * sizeof(*loadmodel->surfmesh.vertexmesh), loadmodel->name, false, false, false);
-
- // upload vertex3f array as a buffer
- if (loadmodel->surfmesh.data_vertex3f && !loadmodel->surfmesh.vertex3fbuffer)
- loadmodel->surfmesh.vertex3fbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.num_vertices * sizeof(float[3]), loadmodel->name, false, false, false);
-
// upload short indices as a buffer
if (loadmodel->surfmesh.data_element3s && !loadmodel->surfmesh.data_element3s_indexbuffer)
- loadmodel->surfmesh.data_element3s_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles * sizeof(short[3]), loadmodel->name, true, false, true);
+ loadmodel->surfmesh.data_element3s_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles * sizeof(short[3]), loadmodel->name, true, false, false, true);
// upload int indices as a buffer
if (loadmodel->surfmesh.data_element3i && !loadmodel->surfmesh.data_element3i_indexbuffer && !loadmodel->surfmesh.data_element3s)
- loadmodel->surfmesh.data_element3i_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles * sizeof(int[3]), loadmodel->name, true, false, false);
+ loadmodel->surfmesh.data_element3i_indexbuffer = R_Mesh_CreateMeshBuffer(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles * sizeof(int[3]), loadmodel->name, true, false, false, false);
// only build a vbo if one has not already been created (this is important for brush models which load specially)
// vertex buffer is several arrays and we put them in the same buffer
// other hand animated models don't use a lot of vertices anyway...
if (!loadmodel->surfmesh.vbo_vertexbuffer && !vid.useinterleavedarrays)
{
- size_t size;
+ int size;
unsigned char *mem;
size = 0;
+ loadmodel->surfmesh.vbooffset_vertexmesh = size;if (loadmodel->surfmesh.data_vertexmesh ) size += loadmodel->surfmesh.num_vertices * sizeof(r_vertexmesh_t);
loadmodel->surfmesh.vbooffset_vertex3f = size;if (loadmodel->surfmesh.data_vertex3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
loadmodel->surfmesh.vbooffset_svector3f = size;if (loadmodel->surfmesh.data_svector3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
loadmodel->surfmesh.vbooffset_tvector3f = size;if (loadmodel->surfmesh.data_tvector3f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
loadmodel->surfmesh.vbooffset_texcoordtexture2f = size;if (loadmodel->surfmesh.data_texcoordtexture2f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
loadmodel->surfmesh.vbooffset_texcoordlightmap2f = size;if (loadmodel->surfmesh.data_texcoordlightmap2f) size += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
loadmodel->surfmesh.vbooffset_lightmapcolor4f = size;if (loadmodel->surfmesh.data_lightmapcolor4f ) size += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
+ loadmodel->surfmesh.vbooffset_skeletalindex4ub = size;if (loadmodel->surfmesh.data_skeletalindex4ub ) size += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
+ loadmodel->surfmesh.vbooffset_skeletalweight4ub = size;if (loadmodel->surfmesh.data_skeletalweight4ub ) size += loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]);
mem = (unsigned char *)Mem_Alloc(tempmempool, size);
+ if (loadmodel->surfmesh.data_vertexmesh ) memcpy(mem + loadmodel->surfmesh.vbooffset_vertexmesh , loadmodel->surfmesh.data_vertexmesh , loadmodel->surfmesh.num_vertices * sizeof(r_vertexmesh_t));
if (loadmodel->surfmesh.data_vertex3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_vertex3f , loadmodel->surfmesh.data_vertex3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
if (loadmodel->surfmesh.data_svector3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_svector3f , loadmodel->surfmesh.data_svector3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
if (loadmodel->surfmesh.data_tvector3f ) memcpy(mem + loadmodel->surfmesh.vbooffset_tvector3f , loadmodel->surfmesh.data_tvector3f , loadmodel->surfmesh.num_vertices * sizeof(float[3]));
if (loadmodel->surfmesh.data_texcoordtexture2f ) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordtexture2f , loadmodel->surfmesh.data_texcoordtexture2f , loadmodel->surfmesh.num_vertices * sizeof(float[2]));
if (loadmodel->surfmesh.data_texcoordlightmap2f) memcpy(mem + loadmodel->surfmesh.vbooffset_texcoordlightmap2f, loadmodel->surfmesh.data_texcoordlightmap2f, loadmodel->surfmesh.num_vertices * sizeof(float[2]));
if (loadmodel->surfmesh.data_lightmapcolor4f ) memcpy(mem + loadmodel->surfmesh.vbooffset_lightmapcolor4f , loadmodel->surfmesh.data_lightmapcolor4f , loadmodel->surfmesh.num_vertices * sizeof(float[4]));
- loadmodel->surfmesh.vbo_vertexbuffer = R_Mesh_CreateMeshBuffer(mem, size, loadmodel->name, false, false, false);
+ if (loadmodel->surfmesh.data_skeletalindex4ub ) memcpy(mem + loadmodel->surfmesh.vbooffset_skeletalindex4ub , loadmodel->surfmesh.data_skeletalindex4ub , loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]));
+ if (loadmodel->surfmesh.data_skeletalweight4ub ) memcpy(mem + loadmodel->surfmesh.vbooffset_skeletalweight4ub , loadmodel->surfmesh.data_skeletalweight4ub , loadmodel->surfmesh.num_vertices * sizeof(unsigned char[4]));
+ loadmodel->surfmesh.vbo_vertexbuffer = R_Mesh_CreateMeshBuffer(mem, size, loadmodel->name, false, false, false, false);
Mem_Free(mem);
}
}
+extern cvar_t mod_obj_orientation;
static void Mod_Decompile_OBJ(dp_model_t *model, const char *filename, const char *mtlfilename, const char *originalfilename)
{
int submodelindex, vertexindex, surfaceindex, triangleindex, textureindex, countvertices = 0, countsurfaces = 0, countfaces = 0, counttextures = 0;
memcpy(outbuffer, oldbuffer, outbufferpos);
Z_Free(oldbuffer);
}
- l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "v %f %f %f\nvn %f %f %f\nvt %f %f\n", v[0], v[2], v[1], vn[0], vn[2], vn[1], vt[0], 1-vt[1]);
+ if(mod_obj_orientation.integer)
+ l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "v %f %f %f\nvn %f %f %f\nvt %f %f\n", v[0], v[2], v[1], vn[0], vn[2], vn[1], vt[0], 1-vt[1]);
+ else
+ l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "v %f %f %f\nvn %f %f %f\nvt %f %f\n", v[0], v[1], v[2], vn[0], vn[1], vn[2], vt[0], 1-vt[1]);
if (l > 0)
outbufferpos += l;
}
a = e[0]+1;
b = e[1]+1;
c = e[2]+1;
- l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", a,a,a,b,b,b,c,c,c);
+ if(mod_obj_orientation.integer)
+ l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", a,a,a,b,b,b,c,c,c);
+ else
+ l = dpsnprintf(outbuffer + outbufferpos, outbuffermax - outbufferpos, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", a,a,a,c,c,c,b,b,b);
if (l > 0)
outbufferpos += l;
}
// strangely the smd angles are for a transposed matrix, so we
// have to generate a transposed matrix, then convert that...
- Matrix4x4_FromBonePose6s(&posematrix, model->num_posescale, model->data_poses6s + 6*(model->num_bones * poseindex + transformindex));
+ Matrix4x4_FromBonePose7s(&posematrix, model->num_posescale, model->data_poses7s + 7*(model->num_bones * poseindex + transformindex));
Matrix4x4_ToArray12FloatGL(&posematrix, mtest[0]);
AnglesFromVectors(angles, mtest[0], mtest[2], false);
if (angles[0] >= 180) angles[0] -= 360;
int zymtextsize = 0;
int dpmtextsize = 0;
int framegroupstextsize = 0;
+ char vabuf[1024];
if (Cmd_Argc() != 2)
{
FS_StripExtension(inname, basename, sizeof(basename));
mod = Mod_ForName(inname, false, true, inname[0] == '*' ? cl.model_name[1] : NULL);
+ if (!mod)
+ {
+ Con_Print("No such model\n");
+ return;
+ }
if (mod->brush.submodel)
{
// if we're decompiling a submodel, be sure to give it a proper name based on its parent
dpsnprintf(basename, sizeof(basename), "%s/%s", outname, mod->name);
outname[0] = 0;
}
- if (!mod)
- {
- Con_Print("No such model\n");
- return;
- }
if (!mod->surfmesh.num_triangles)
{
Con_Print("Empty model (or sprite)\n");
{
// individual frame
// check for additional frames with same name
- for (l = 0, k = strlen(animname);animname[l];l++)
+ for (l = 0, k = (int)strlen(animname);animname[l];l++)
if(animname[l] < '0' || animname[l] > '9')
k = l + 1;
if(k > 0 && animname[k-1] == '_')
for (j = i + 1;j < mod->numframes;j++)
{
strlcpy(animname2, mod->animscenes[j].name, sizeof(animname2));
- for (l = 0, k = strlen(animname2);animname2[l];l++)
+ for (l = 0, k = (int)strlen(animname2);animname2[l];l++)
if(animname2[l] < '0' || animname2[l] > '9')
k = l + 1;
if(k > 0 && animname[k-1] == '_')
}
}
if (zymtextsize)
- FS_WriteFile(va("%s_decompiled/out_zym.txt", basename), zymtextbuffer, (fs_offset_t)zymtextsize);
+ FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_decompiled/out_zym.txt", basename), zymtextbuffer, (fs_offset_t)zymtextsize);
if (dpmtextsize)
- FS_WriteFile(va("%s_decompiled/out_dpm.txt", basename), dpmtextbuffer, (fs_offset_t)dpmtextsize);
+ FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_decompiled/out_dpm.txt", basename), dpmtextbuffer, (fs_offset_t)dpmtextsize);
if (framegroupstextsize)
- FS_WriteFile(va("%s_decompiled.framegroups", basename), framegroupstextbuffer, (fs_offset_t)framegroupstextsize);
+ FS_WriteFile(va(vabuf, sizeof(vabuf), "%s_decompiled.framegroups", basename), framegroupstextbuffer, (fs_offset_t)framegroupstextsize);
}
}
static int mod_generatelightmaps_numlights;
static lightmaplight_t *mod_generatelightmaps_lightinfo;
-extern int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color);
extern cvar_t r_shadow_lightattenuationdividebias;
extern cvar_t r_shadow_lightattenuationlinearscale;
if (model->surfmesh.num_vertices > 65536)
model->surfmesh.data_element3s = NULL;
- if (model->surfmesh.vertexmesh)
- Mem_Free(model->surfmesh.vertexmesh);
- model->surfmesh.vertexmesh = NULL;
- if (model->surfmesh.vertex3fbuffer)
- R_Mesh_DestroyMeshBuffer(model->surfmesh.vertex3fbuffer);
- model->surfmesh.vertex3fbuffer = NULL;
- if (model->surfmesh.vertexmeshbuffer)
- R_Mesh_DestroyMeshBuffer(model->surfmesh.vertexmeshbuffer);
- model->surfmesh.vertexmeshbuffer = NULL;
if (model->surfmesh.data_element3i_indexbuffer)
R_Mesh_DestroyMeshBuffer(model->surfmesh.data_element3i_indexbuffer);
model->surfmesh.data_element3i_indexbuffer = NULL;
unsigned char *lightmappixels;
unsigned char *deluxemappixels;
mod_alloclightmap_state_t lmstate;
+ char vabuf[1024];
// generate lightmap projection information for all triangles
if (model->texturepool == NULL)
for (lightmapindex = 0;lightmapindex < model->brushq3.num_mergedlightmaps;lightmapindex++)
{
- model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("lightmap%i", lightmapindex), lm_texturesize, lm_texturesize, lightmappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR, -1, NULL);
- model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("deluxemap%i", lightmapindex), lm_texturesize, lm_texturesize, deluxemappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR, -1, NULL);
+ model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va(vabuf, sizeof(vabuf), "lightmap%i", lightmapindex), lm_texturesize, lm_texturesize, lightmappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR, -1, NULL);
+ model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va(vabuf, sizeof(vabuf), "deluxemap%i", lightmapindex), lm_texturesize, lm_texturesize, deluxemappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR, -1, NULL);
}
if (lightmappixels)
for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
{
surface = model->data_surfaces + surfaceindex;
- e = model->surfmesh.data_element3i + surface->num_firsttriangle*3;
if (!surface->num_triangles)
continue;
lightmapindex = mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle].lightmapindex;