tech
/
engine
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

finally fix fbsp lightgrid. 

fix issue where framegroups with no poses were causing a crash. now causes spam.
implement sneaky trick to munge lightmaps a little, greatly accelerating stuff like sock's map.
fix q3 physics issue (was probably bugging out q2 too).

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@4922 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike 2015-06-28 00:42:00 +00:00
parent d81bf36c68
commit 5ef22569cd
10 changed files with 181 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
engine/client/r_surf.c
View File

@ -2735,7 +2735,7 @@ void Surf_BuildModelLightmaps (model_t *m)
{
if (lightmap_bgra && lightmap_bytes == 4)
{
for (j = 0; j < m->lightmaps.width*m->lightmaps.height; j++, dst += 4, src += 3)
for (j = min((m->lightdatasize-i*m->lightmaps.width*m->lightmaps.height*3)/3,m->lightmaps.width*m->lightmaps.height); j > 0; j--, dst += 4, src += 3)
{
dst[0] = src[2];
dst[1] = src[1];

11
engine/common/com_mesh.c
View File

@ -1825,6 +1825,8 @@ qboolean Alias_GAliasBuildMesh(mesh_t *mesh, vbo_t **vbop, galiasinfo_t *inf, in
else
#endif
{
//FIXME: replace most of this logic with Alias_BuildSkelLerps
frame1 = e->framestate.g[FS_REG].frame[0];
frame2 = e->framestate.g[FS_REG].frame[1];
lerp = e->framestate.g[FS_REG].lerpweight[1]; //FIXME
@ -1860,6 +1862,15 @@ qboolean Alias_GAliasBuildMesh(mesh_t *mesh, vbo_t **vbop, galiasinfo_t *inf, in
g1 = &inf->ofsanimations[frame1];
g2 = &inf->ofsanimations[frame2];
if (!inf->numanimations || !g1->numposes || !g2->numposes)
{
Con_Printf("Invalid animation data on entity with model %s\n", e->model->name);
//no animation data. panic!
memset(mesh, 0, sizeof(*mesh));
*vbop = NULL;
return false;
}
if (g1 == g2) //lerping within group is only done if not changing group
{
lerp = fg1time*g1->rate;

46
engine/common/gl_q2bsp.c
View File

@ -2895,6 +2895,7 @@ qboolean CModQ3_LoadRFaces (model_t *mod, qbyte *mod_base, lump_t *l)
out->lightmaptexturenums[sty] = -1;
}
out->lmshift = LMSHIFT_DEFAULT;
//fixme: determine texturemins from lightmap_origin
out->extents[0] = (LittleLong(in->lightmap_width)-1)<<out->lmshift;
out->extents[1] = (LittleLong(in->lightmap_height)-1)<<out->lmshift;
out->samples=NULL;
@ -3466,6 +3467,7 @@ void CModQ3_LoadLighting (model_t *loadmodel, qbyte *mod_base, lump_t *l)
loadmodel->engineflags |= MDLF_RGBLIGHTING;
loadmodel->lightdata = out = ZG_Malloc(&loadmodel->memgroup, samples);
loadmodel->lightdatasize = samples;
//be careful here, q3bsp deluxemapping is done using interleaving. we want to unoverbright ONLY lightmaps and not deluxemaps.
for (m = 0; m < maps; m++)
@ -4451,23 +4453,19 @@ void CM_InitBoxHull (void)
{
side = i&1;
// brush sides
//the pointers
s = &box_sides[i];
s->plane = box_planes + (i*2+side);
p = &box_planes[i];
// brush sides
s->plane = p;
s->surface = &nullsurface;
// planes
p = &box_planes[i*2];
p->type = i>>1;
p->type = ((i>=3)?i-3:i);
p->signbits = 0;
VectorClear (p->normal);
p->normal[i>>1] = 1;
p = &box_planes[i*2+1];
p->type = 3 + (i>>1);
p->signbits = 0;
VectorClear (p->normal);
p->normal[i>>1] = -1;
p->normal[p->type] = ((i>=3)?-1:1);
}
}
@ -4483,17 +4481,11 @@ BSP trees instead of being compared directly.
void CM_SetTempboxSize (vec3_t mins, vec3_t maxs)
{
box_planes[0].dist = maxs[0];
box_planes[1].dist = -maxs[0];
box_planes[2].dist = mins[0];
box_planes[1].dist = maxs[1];
box_planes[2].dist = maxs[2];
box_planes[3].dist = -mins[0];
box_planes[4].dist = maxs[1];
box_planes[5].dist = -maxs[1];
box_planes[6].dist = mins[1];
box_planes[7].dist = -mins[1];
box_planes[8].dist = maxs[2];
box_planes[9].dist = -maxs[2];
box_planes[10].dist = mins[2];
box_planes[11].dist = -mins[2];
box_planes[4].dist = -mins[1];
box_planes[5].dist = -mins[2];
}
model_t *CM_TempBoxModel(vec3_t mins, vec3_t maxs)
@ -5837,6 +5829,12 @@ static qboolean BM_NativeTrace(model_t *model, int forcehullnum, int frame, vec3
if (contents & FTECONTENTS_BODY)
{
trace_contents = contents;
VectorCopy (start, trace_start);
VectorCopy (end, trace_end);
VectorCopy (mins, trace_mins);
VectorCopy (maxs, trace_maxs);
if (trace_mins[0] == 0 && trace_mins[1] == 0 && trace_mins[2] == 0 && trace_maxs[0] == 0 && trace_maxs[1] == 0 && trace_maxs[2] == 0)
trace_shape = shape_ispoint;
else if (capsule)
@ -5844,12 +5842,6 @@ static qboolean BM_NativeTrace(model_t *model, int forcehullnum, int frame, vec3
else
trace_shape = shape_isbox;
trace_contents = contents;
VectorCopy (start, trace_start);
VectorCopy (end, trace_end);
VectorCopy (mins, trace_mins);
VectorCopy (maxs, trace_maxs);
CM_ClipBoxToBrush (trace_mins, trace_maxs, trace_start, trace_end, trace, &box_brush);
}

5
engine/gl/gl_alias.c
View File

@ -1444,6 +1444,11 @@ void R_GAlias_DrawBatch(batch_t *batch)
{
/*needrecolour =*/ Alias_GAliasBuildMesh(&mesh, &batch->vbo, inf, surfnum, e, batch->shader->prog && batch->shader->prog->permu[PERMUTATION_SKELETAL].handle.glsl.handle);
batch->mesh = &meshl;
if (!mesh.numindexes)
{
batch->meshes = 0; //something went screwy
batch->mesh = NULL;
}
return;
}
}

10
engine/gl/gl_backend.c
View File

@ -3944,6 +3944,14 @@ static void DrawMeshes(void)
shaderstate.pendingvertexvbo = shaderstate.sourcevbo->coord.gl.vbo;
}
#ifdef _DEBUG
if (!shaderstate.pendingvertexpointer && !shaderstate.pendingvertexvbo)
{
Con_Printf(CON_ERROR "pendingvertexpointer+vbo are both null! shader is %s\n", shaderstate.curshader->name);
return;
}
#endif
#ifdef FTE_TARGET_WEB
if (!shaderstate.pendingvertexvbo)
return;
@ -4499,7 +4507,7 @@ static void GLBE_SubmitMeshesSortList(batch_t *sortlist)
continue;
}
if (bs->flags & SHADER_NODRAW)
if ((bs->flags & SHADER_NODRAW) || !batch->meshes)
continue;
if (bs->flags & SHADER_NODLIGHT)
if (shaderstate.mode == BEM_LIGHT)

87
engine/gl/gl_model.c
View File

@ -125,7 +125,7 @@ static void Mod_MemList_f(void)
#ifndef SERVERONLY
static void Mod_BatchList_f(void)
{
int m, i;
int m, i, lm;
model_t *mod;
batch_t *batch;
unsigned int count;
@ -2663,14 +2663,14 @@ void ModQ1_Batches_BuildQ1Q2Poly(model_t *mod, msurface_t *surf, builddata_t *co
}
#ifndef SERVERONLY
static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindicies, void (*build)(model_t *mod, msurface_t *surf, builddata_t *bd), builddata_t *bd)
static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindicies, void (*build)(model_t *mod, msurface_t *surf, builddata_t *bd), builddata_t *bd, int lmmerge)
{
batch_t *batch;
msurface_t *surf;
mesh_t *mesh;
int numverts = 0;
int numindicies = 0;
int j;
int j, i;
int sortid;
int sty;
vbo_t vbo;
@ -2749,6 +2749,23 @@ static void Mod_Batches_BuildModelMeshes(model_t *mod, int maxverts, int maxindi
mesh->vbofirstelement = 0;
build(mod, surf, bd);
if (lmmerge != 1)
for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
{
if (surf->lightmaptexturenums[sty] >= 0)
{
if (mesh->lmst_array[sty])
{
for (i = 0; i < mesh->numvertexes; i++)
{
mesh->lmst_array[sty][i][1] += surf->lightmaptexturenums[sty] % lmmerge;
mesh->lmst_array[sty][i][1] /= lmmerge;
}
}
surf->lightmaptexturenums[sty] /= lmmerge;
}
}
}
batch->meshes = 0;
batch->firstmesh = 0;
@ -2810,10 +2827,11 @@ void Mod_UpdateBatchShader_Q2 (struct batch_s *batch)
batch->shader = base->shader;
}
#define lmmerge(i) ((i>=0)?i/merge:i)
/*
batch->firstmesh is set only in and for this function, its cleared out elsewhere
*/
static void Mod_Batches_Generate(model_t *mod)
static int Mod_Batches_Generate(model_t *mod)
{
int i;
msurface_t *surf;
@ -2822,6 +2840,18 @@ static void Mod_Batches_Generate(model_t *mod)
batch_t *batch, *lbatch = NULL;
vec4_t plane;
int merge = sh_config.texture_maxsize / mod->lightmaps.height;
while (merge > mod->lightmaps.count)
merge /= 2;
if (merge < 1)//erk?
merge = 1;
mod->lightmaps.count = (mod->lightmaps.count+merge-1) & ~(merge-1);
mod->lightmaps.count /= merge;
mod->lightmaps.height *= merge;
//for each surface, find a suitable batch to insert it into.
//we use 'firstmesh' to avoid chucking out too many verts in a single vbo (gl2 hardware tends to have a 16bit limit)
for (i=0; i<mod->nummodelsurfaces; i++)
@ -2862,13 +2892,13 @@ static void Mod_Batches_Generate(model_t *mod)
if (lbatch && (
lbatch->texture == surf->texinfo->texture &&
lbatch->lightmap[0] == surf->lightmaptexturenums[0] &&
lbatch->lightmap[0] == lmmerge(surf->lightmaptexturenums[0]) &&
Vector4Compare(plane, lbatch->plane) &&
lbatch->firstmesh + surf->mesh->numvertexes <= MAX_INDICIES) &&
#if MAXRLIGHTMAPS > 1
lbatch->lightmap[1] == surf->lightmaptexturenums[1] &&
lbatch->lightmap[2] == surf->lightmaptexturenums[2] &&
lbatch->lightmap[3] == surf->lightmaptexturenums[3] &&
lbatch->lightmap[1] == lmmerge(surf->lightmaptexturenums[1]) &&
lbatch->lightmap[2] == lmmerge(surf->lightmaptexturenums[2]) &&
lbatch->lightmap[3] == lmmerge(surf->lightmaptexturenums[3]) &&
#endif
lbatch->fog == surf->fog)
batch = lbatch;
@ -2878,13 +2908,13 @@ static void Mod_Batches_Generate(model_t *mod)
{
if (
batch->texture == surf->texinfo->texture &&
batch->lightmap[0] == surf->lightmaptexturenums[0] &&
batch->lightmap[0] == lmmerge(surf->lightmaptexturenums[0]) &&
Vector4Compare(plane, batch->plane) &&
batch->firstmesh + surf->mesh->numvertexes <= MAX_INDICIES &&
#if MAXRLIGHTMAPS > 1
batch->lightmap[1] == surf->lightmaptexturenums[1] &&
batch->lightmap[2] == surf->lightmaptexturenums[2] &&
batch->lightmap[3] == surf->lightmaptexturenums[3] &&
batch->lightmap[1] == lmmerge(surf->lightmaptexturenums[1]) &&
batch->lightmap[2] == lmmerge(surf->lightmaptexturenums[2]) &&
batch->lightmap[3] == lmmerge(surf->lightmaptexturenums[3]) &&
#endif
batch->fog == surf->fog)
break;
@ -2893,11 +2923,11 @@ static void Mod_Batches_Generate(model_t *mod)
if (!batch)
{
batch = ZG_Malloc(&mod->memgroup, sizeof(*batch));
batch->lightmap[0] = surf->lightmaptexturenums[0];
batch->lightmap[0] = lmmerge(surf->lightmaptexturenums[0]);
#if MAXRLIGHTMAPS > 1
batch->lightmap[1] = surf->lightmaptexturenums[1];
batch->lightmap[2] = surf->lightmaptexturenums[2];
batch->lightmap[3] = surf->lightmaptexturenums[3];
batch->lightmap[1] = lmmerge(surf->lightmaptexturenums[1]);
batch->lightmap[2] = lmmerge(surf->lightmaptexturenums[2]);
batch->lightmap[3] = lmmerge(surf->lightmaptexturenums[3]);
#endif
batch->texture = surf->texinfo->texture;
batch->shader = surf->texinfo->texture->shader;
@ -2922,6 +2952,9 @@ static void Mod_Batches_Generate(model_t *mod)
lbatch = batch;
}
return merge;
#undef lmmerge
}
void Mod_LightmapAllocInit(lmalloc_t *lmallocator, qboolean hasdeluxe, unsigned int width, unsigned int height, int firstlm)
@ -2938,7 +2971,7 @@ void Mod_LightmapAllocDone(lmalloc_t *lmallocator, model_t *mod)
{
mod->lightmaps.first = lmallocator->firstlm;
mod->lightmaps.count = (lmallocator->lmnum - lmallocator->firstlm);
if (lmallocator->allocated[0])
if (lmallocator->allocated[0]) //lmnum was only *COMPLETE* lightmaps that we allocated, and does not include the one we're currently building.
mod->lightmaps.count++;
if (lmallocator->deluxe)
@ -3015,7 +3048,7 @@ static void Mod_LightmapAllocSurf(lmalloc_t *lmallocator, msurface_t *surf, int
Mod_LightmapAllocBlock (lmallocator, smax, tmax, &surf->light_s[surfstyle], &surf->light_t[surfstyle], &surf->lightmaptexturenums[surfstyle]);
}
static void Mod_Batches_SplitLightmaps(model_t *mod)
static void Mod_Batches_SplitLightmaps(model_t *mod, int lmmerge)
{
batch_t *batch;
batch_t *nb;
@ -3023,14 +3056,13 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
msurface_t *surf;
int sty;
for (sortid = 0; sortid < SHADER_SORT_COUNT; sortid++)
for (batch = mod->batches[sortid]; batch != NULL; batch = batch->next)
{
surf = (msurface_t*)batch->mesh[0];
for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
{
batch->lightmap[sty] = surf->lightmaptexturenums[sty];
batch->lightmap[sty] = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
batch->lmlightstyle[sty] = surf->styles[sty];
}
@ -3039,7 +3071,8 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
surf = (msurface_t*)batch->mesh[j];
for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
{
if (surf->lightmaptexturenums[sty] != batch->lightmap[sty] ||
int lm = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
if (lm != batch->lightmap[sty] ||
//fixme: we should merge later (reverted matching) surfaces into the prior batch
surf->styles[sty] != batch->lmlightstyle[sty] ||
surf->vlstyles[sty] != batch->vtlightstyle[sty])
@ -3056,7 +3089,8 @@ static void Mod_Batches_SplitLightmaps(model_t *mod)
batch->maxmeshes = j;
for (sty = 0; sty < MAXRLIGHTMAPS; sty++)
{
nb->lightmap[sty] = surf->lightmaptexturenums[sty];
int lm = (surf->lightmaptexturenums[sty]>=0)?surf->lightmaptexturenums[sty]/lmmerge:surf->lightmaptexturenums[sty];
nb->lightmap[sty] = lm;
nb->lmlightstyle[sty] = surf->styles[sty];
nb->vtlightstyle[sty] = surf->vlstyles[sty];
}
@ -3179,6 +3213,7 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
int sortid;
batch_t *batch;
mesh_t *meshlist;
int merge = 1;
currentmodel = mod;
@ -3208,7 +3243,7 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
}
/*assign each mesh to a batch, generating as needed*/
Mod_Batches_Generate(mod);
merge = Mod_Batches_Generate(mod);
bmeshes = ZG_Malloc(&mod->memgroup, sizeof(*bmeshes)*mod->nummodelsurfaces*R_MAX_RECURSE);
@ -3227,17 +3262,17 @@ static void Mod_Batches_Build(model_t *mod, builddata_t *bd)
surf->sbatch->mesh[surf->sbatch->meshes++] = (mesh_t*)surf;
}
if (bd) //q3
Mod_Batches_SplitLightmaps(mod);
Mod_Batches_SplitLightmaps(mod, merge);
else
Mod_Batches_AllocLightmaps(mod);
if (!bd)
{
mod->lightmaps.surfstyles = 1;
Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, ModQ1_Batches_BuildQ1Q2Poly, bd);
Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, ModQ1_Batches_BuildQ1Q2Poly, bd, merge);
}
else
Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, bd->buildfunc, bd);
Mod_Batches_BuildModelMeshes(mod, numverts, numindicies, bd->buildfunc, bd, merge);
if (BE_GenBrushModelVBO)
BE_GenBrushModelVBO(mod);

134
engine/gl/gl_rlight.c
View File

@ -1086,24 +1086,26 @@ LIGHT SAMPLING
mplane_t *lightplane;
vec3_t lightspot;
static void GLQ3_AddLatLong(qbyte latlong[2], vec3_t dir, float mag)
{
float lat = (float)latlong[0] * (2 * M_PI)*(1.0 / 255.0);
float lng = (float)latlong[1] * (2 * M_PI)*(1.0 / 255.0);
dir[0] += mag * cos ( lng ) * sin ( lat );
dir[1] += mag * sin ( lng ) * sin ( lat );
dir[2] += mag * cos ( lat );
}
void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t res_dir)
{
q3lightgridinfo_t *lg = (q3lightgridinfo_t *)cl.worldmodel->lightgrid;
int index[8];
int vi[3];
int i, j;
float t[8], direction_uv[3];
float t[8];
vec3_t vf, vf2;
vec3_t ambient, diffuse;
vec3_t ambient, diffuse, direction;
if (res_dir)
{
res_dir[0] = 1;
res_dir[1] = 1;
res_dir[2] = 0.1;
}
if (!lg || !lg->lightgrid)
if (!lg || (!lg->lightgrid && !lg->rbspelements) || lg->numlightgridelems < 1)
{
if(res_ambient)
{
@ -1118,6 +1120,13 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
res_diffuse[1] = 192;
res_diffuse[2] = 192;
}
if (res_dir)
{
res_dir[0] = 1;
res_dir[1] = 1;
res_dir[2] = 0.1;
}
return;
}
@ -1132,73 +1141,64 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
vf2[i] = 1.0f - vf[i];
}
index[0] = vi[2]*lg->gridBounds[3] + vi[1]*lg->gridBounds[0] + vi[0];
index[1] = index[0] + lg->gridBounds[0];
index[2] = index[0] + lg->gridBounds[3];
index[3] = index[2] + lg->gridBounds[0];
index[4] = index[0]+(index[0]<(lg->numlightgridelems-1));
index[5] = index[1]+(index[1]<(lg->numlightgridelems-1));
index[6] = index[2]+(index[2]<(lg->numlightgridelems-1));
index[7] = index[3]+(index[3]<(lg->numlightgridelems-1));
for ( i = 0; i < 8; i++ )
{
if ( index[i] < 0 || index[i] >= (lg->numlightgridelems) )
{
res_ambient[0] = 255; //out of the map
res_ambient[1] = 255;
res_ambient[2] = 255;
//bound it properly
index[i] = bound(0, vi[0]+((i&1)?1:0), lg->gridBounds[0]-1) * 1 +
bound(0, vi[1]+((i&2)?1:0), lg->gridBounds[1]-1) * lg->gridBounds[0] +
bound(0, vi[2]+((i&4)?1:0), lg->gridBounds[2]-1) * lg->gridBounds[3] ;
t[i] = ((i&1)?vf[0]:vf2[0]) *
((i&2)?vf[1]:vf2[1]) *
((i&4)?vf[2]:vf2[2]) ;
}
if (res_diffuse)
//rbsp has a separate grid->index lookup for compression.
if (lg->rbspindexes)
{
for (i = 0; i < 8; i++)
index[i] = lg->rbspindexes[index[i]];
}
VectorClear(ambient);
VectorClear(diffuse);
VectorClear(direction);
if (lg->rbspelements)
{
for (i = 0; i < 8; i++)
{ //rbsp has up to 4 styles per grid element, which needs to be scaled by that style's current value
float tot = 0;
for (j = 0; j < countof(lg->rbspelements[index[i]].styles); j++)
{
res_diffuse[0] = 255;
res_diffuse[1] = 255;
res_diffuse[2] = 255;
qbyte st = lg->rbspelements[index[i]].styles[j];
if (st != 255)
{
float mag = d_lightstylevalue[st] * 1.0/255 * t[i];
//FIXME: cl_lightstyle[st].colours[rgb]
VectorMA (ambient, mag, lg->rbspelements[index[i]].ambient[j], ambient);
VectorMA (diffuse, mag, lg->rbspelements[index[i]].diffuse[j], diffuse);
tot += mag;
}
}
return;
GLQ3_AddLatLong(lg->rbspelements[index[i]].direction, direction, tot);
}
}
t[0] = vf2[0] * vf2[1] * vf2[2];
t[1] = vf[0] * vf2[1] * vf2[2];
t[2] = vf2[0] * vf[1] * vf2[2];
t[3] = vf[0] * vf[1] * vf2[2];
t[4] = vf2[0] * vf2[1] * vf[2];
t[5] = vf[0] * vf2[1] * vf[2];
t[6] = vf2[0] * vf[1] * vf[2];
t[7] = vf[0] * vf[1] * vf[2];
for ( j = 0; j < 3; j++ )
else
{
ambient[j] = 0;
diffuse[j] = 0;
for ( i = 0; i < 4; i++ )
for (i = 0; i < 8; i++)
{
ambient[j] += t[i*2] * lg->lightgrid[ index[i]].ambient[j];
ambient[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].ambient[j];
diffuse[j] += t[i*2] * lg->lightgrid[ index[i]].diffuse[j];
diffuse[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].diffuse[j];
}
}
for ( j = 0; j < 2; j++ )
{
direction_uv[j] = 0;
for ( i = 0; i < 4; i++ )
{
direction_uv[j] += t[i*2] * lg->lightgrid[ index[i]].direction[j];
direction_uv[j] += t[i*2+1] * lg->lightgrid[ index[i+4]].direction[j];
VectorMA (ambient, t[i], lg->lightgrid[index[i]].ambient, ambient);
VectorMA (diffuse, t[i], lg->lightgrid[index[i]].diffuse, diffuse);
GLQ3_AddLatLong(lg->lightgrid[index[i]].direction, direction, t[i]);
}
direction_uv[j] = anglemod ( direction_uv[j] );
VectorScale(ambient, d_lightstylevalue[0]/255.0, ambient);
VectorScale(diffuse, d_lightstylevalue[0]/255.0, diffuse);
//FIXME: cl_lightstyle[0].colours[rgb]
}
VectorScale(ambient, 4, ambient);
VectorScale(diffuse, 4, diffuse);
//q3bsp has *4 overbrighting.
// VectorScale(ambient, 4, ambient);
// VectorScale(diffuse, 4, diffuse);
/*ambient is the min level*/
/*diffuse is the max level*/
@ -1206,11 +1206,7 @@ void GLQ3_LightGrid(model_t *mod, vec3_t point, vec3_t res_diffuse, vec3_t res_a
if (res_diffuse)
VectorAdd(diffuse, ambient, res_diffuse);
if (res_dir)
{
vec3_t right, left;
direction_uv[2] = 0;
AngleVectors(direction_uv, res_dir, right, left);
}
VectorCopy(direction, res_dir);
}
int GLRecursiveLightPoint (mnode_t *node, vec3_t start, vec3_t end)

3
engine/gl/gl_rmisc.c
View File

@ -484,6 +484,9 @@ void GLR_TimeRefresh_f (void)
if (frames < 1)
frames = 128;
if (!r_refdef.playerview)
r_refdef.playerview = &cl.playerview[0];
if (finish == 2)
{
qglFinish ();

8
engine/server/svq3_game.c
View File

@ -156,14 +156,18 @@ static void Q3G_UnlinkEntity(q3sharedEntity_t *ent)
static model_t *Q3G_GetCModel(unsigned int modelindex)
{
//0 is world
//1 == *1
//this is not how quake's precaches normally work.
modelindex++;
if ((unsigned int)modelindex < MAX_PRECACHE_MODELS)
{
if (!sv.models[modelindex])
{
if (modelindex == 0)
if (modelindex == 1)
sv.models[modelindex] = sv.world.worldmodel;
else
sv.models[modelindex] = Mod_ForName(Mod_FixName(va("*%i", modelindex), sv.modelname), MLV_WARN);
sv.models[modelindex] = Mod_ForName(Mod_FixName(va("*%i", modelindex-1), sv.modelname), MLV_WARN);
}
if (sv.models[modelindex]->loadstate == MLS_LOADING)

2
plugins/jabber/jabberclient.c
View File

@ -903,7 +903,7 @@ static int sasl_scramsha1_challenge(jclient_t *jcl, char *in, int inlen, char *o
SHA1_Hi(salted_password, password, strlen(password), &salt, atoi(itr.buf));
SHA1_HMAC(clientkey, sizeof(clientkey), "Client Key", strlen("Client Key"), salted_password, sizeof(salted_password));
SHA1(storedkey, sizeof(storedkey), clientkey, sizeof(clientkey));
SHA1(storedkey, sizeof(storedkey), clientkey, sizeof(clientkey)); //FIXME: switch the account's plain password to store this digest instead (with salt+itr).
SHA1_HMAC(clientsignature, sizeof(clientsignature), sigkey.buf, sigkey.len, storedkey, sizeof(storedkey));
for (i = 0; i < sizeof(proof); i++)