marrub
/
HLua
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
HLua/utils/qrad/lightmap.c

1724 lines
38 KiB
C
Raw Permalink Blame History

/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
****/
#include "qrad.h"
typedef struct
{
dface_t *faces[2];
vec3_t interface_normal;
qboolean coplanar;
} edgeshare_t;
edgeshare_t edgeshare[MAX_MAP_EDGES];
vec3_t face_centroids[MAX_MAP_EDGES];
#ifdef OBSOLETE_CODE
int facelinks[MAX_MAP_FACES];
int planelinks[2][MAX_MAP_PLANES];
/*
============
LinkPlaneFaces
============
*/
void LinkPlaneFaces (void)
{
int i;
dface_t *f;
f = dfaces;
for (i=0 ; i<numfaces ; i++, f++)
{
facelinks[i] = planelinks[f->side][f->planenum];
planelinks[f->side][f->planenum] = i;
}
}
#endif
/*
============
PairEdges
============
*/
void PairEdges (void)
{
int i, j, k, n;
dface_t *f;
edgeshare_t *e;
f = dfaces;
for (i=0 ; i<numfaces ; i++, f++)
{
for (j=0 ; j<f->numedges ; j++)
{
k = dsurfedges[f->firstedge + j];
if (k < 0)
{
e = &edgeshare[-k];
e->faces[1] = f;
}
else
{
e = &edgeshare[k];
e->faces[0] = f;
}
if (e->faces[0] && e->faces[1])
{
// determine if coplanar
if (e->faces[0]->planenum == e->faces[1]->planenum)
e->coplanar = true;
else if ( smoothing_threshold > 0 )
{
// see if they fall into a "smoothing group" based on angle of the normals
vec3_t normals[2];
double cos_normals_angle;
for(n=0; n<2; n++)
{
VectorCopy( dplanes[e->faces[n]->planenum].normal, normals[n] );
if ( e->faces[n]->side )
VectorSubtract( vec3_origin, normals[n], normals[n] );
}
cos_normals_angle = DotProduct( normals[0], normals[1] );
if ( cos_normals_angle >= smoothing_threshold )
{
VectorAdd( normals[0], normals[1], e->interface_normal );
VectorNormalize( e->interface_normal );
}
}
}
}
}
}
/*
=================================================================
POINT TRIANGULATION
=================================================================
*/
typedef struct triedge_s
{
int p0, p1;
vec3_t normal;
vec_t dist;
struct triangle_s *tri;
} triedge_t;
typedef struct triangle_s
{
triedge_t *edges[3];
} triangle_t;
#define MAX_TRI_POINTS 2048 // Was 1024 originally.
#define MAX_TRI_EDGES (MAX_TRI_POINTS*6)
#define MAX_TRI_TRIS (MAX_TRI_POINTS*2)
typedef struct
{
int numpoints;
int numedges;
int numtris;
dplane_t *plane;
triedge_t *edgematrix[MAX_TRI_POINTS][MAX_TRI_POINTS];
patch_t *points[MAX_TRI_POINTS];
triedge_t edges[MAX_TRI_EDGES];
triangle_t tris[MAX_TRI_TRIS];
} triangulation_t;
/*
===============
AllocTriangulation
===============
*/
triangulation_t *AllocTriangulation (dplane_t *plane)
{
triangulation_t *t = NULL;
HANDLE h;
if ( h = GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT, sizeof(triangulation_t) ) )
{
t = GlobalLock( h );
t->numpoints = 0;
t->numedges = 0;
t->numtris = 0;
t->plane = plane;
}
else
Error("Cannot alloc triangulation memory!");
return t;
}
/*
===============
FreeTriangulation
===============
*/
void FreeTriangulation (triangulation_t *tr)
{
HANDLE h = GlobalHandle(tr);
if ( h )
{
GlobalUnlock(h);
GlobalFree(h);
}
else
Error("Cannot free triangulation memory!");
}
triedge_t *FindEdge (triangulation_t *trian, int p0, int p1)
{
triedge_t *e, *be;
vec3_t v1;
vec3_t normal;
vec_t dist;
if (trian->edgematrix[p0][p1])
return trian->edgematrix[p0][p1];
if (trian->numedges > MAX_TRI_EDGES-2)
Error ("trian->numedges > MAX_TRI_EDGES-2");
VectorSubtract (trian->points[p1]->origin, trian->points[p0]->origin, v1);
VectorNormalize (v1);
CrossProduct (v1, trian->plane->normal, normal);
dist = DotProduct (trian->points[p0]->origin, normal);
e = &trian->edges[trian->numedges];
e->p0 = p0;
e->p1 = p1;
e->tri = NULL;
VectorCopy (normal, e->normal);
e->dist = dist;
trian->numedges++;
trian->edgematrix[p0][p1] = e;
be = &trian->edges[trian->numedges];
be->p0 = p1;
be->p1 = p0;
be->tri = NULL;
VectorSubtract (vec3_origin, normal, be->normal);
be->dist = -dist;
trian->numedges++;
trian->edgematrix[p1][p0] = be;
return e;
}
triangle_t *AllocTriangle (triangulation_t *trian)
{
triangle_t *t;
if (trian->numtris >= MAX_TRI_TRIS)
Error ("trian->numtris >= MAX_TRI_TRIS");
t = &trian->tris[trian->numtris];
trian->numtris++;
return t;
}
/*
============
TriEdge_r
============
*/
void TriEdge_r (triangulation_t *trian, triedge_t *e)
{
int i, bestp;
vec3_t v1, v2;
vec_t *p0, *p1, *p;
vec_t best, ang;
triangle_t *nt;
if (e->tri)
return; // allready connected by someone
// find the point with the best angle
p0 = trian->points[e->p0]->origin;
p1 = trian->points[e->p1]->origin;
best = 1.1f;
for (i=0 ; i< trian->numpoints ; i++)
{
p = trian->points[i]->origin;
// a 0 dist will form a degenerate triangle
if (DotProduct(p, e->normal) - e->dist < 0)
continue; // behind edge
VectorSubtract (p0, p, v1);
VectorSubtract (p1, p, v2);
if (!VectorNormalize (v1))
continue;
if (!VectorNormalize (v2))
continue;
ang = DotProduct (v1, v2);
if (ang < best)
{
best = ang;
bestp = i;
}
}
if (best >= 1)
return; // edge doesn't match anything
// make a new triangle
nt = AllocTriangle (trian);
nt->edges[0] = e;
nt->edges[1] = FindEdge (trian, e->p1, bestp);
nt->edges[2] = FindEdge (trian, bestp, e->p0);
for (i=0 ; i<3 ; i++)
nt->edges[i]->tri = nt;
TriEdge_r (trian, FindEdge (trian, bestp, e->p1));
TriEdge_r (trian, FindEdge (trian, e->p0, bestp));
}
/*
============
TriangulatePoints
============
*/
void TriangulatePoints (triangulation_t *trian)
{
vec_t d, bestd;
vec3_t v1;
int bp1, bp2, i, j;
vec_t *p1, *p2;
triedge_t *e, *e2;
if (trian->numpoints < 2)
return;
// find the two closest points
bestd = 9999;
for (i=0 ; i<trian->numpoints ; i++)
{
p1 = trian->points[i]->origin;
for (j=i+1 ; j<trian->numpoints ; j++)
{
p2 = trian->points[j]->origin;
VectorSubtract (p2, p1, v1);
d = (float)VectorLength (v1);
if (d < bestd)
{
bestd = d;
bp1 = i;
bp2 = j;
}
}
}
e = FindEdge (trian, bp1, bp2);
e2 = FindEdge (trian, bp2, bp1);
TriEdge_r (trian, e);
TriEdge_r (trian, e2);
}
/*
===============
AddPatchToTriangulation
===============
*/
void AddPatchToTriangulation (patch_t *patch, triangulation_t *trian)
{
int pnum;
pnum = trian->numpoints;
if (pnum == MAX_TRI_POINTS)
Error ("trian->numpoints == MAX_TRI_POINTS");
trian->points[pnum] = patch;
trian->numpoints++;
}
/*
===============
LerpTriangle
===============
*/
void LerpTriangle (triangulation_t *trian, triangle_t *t, vec3_t point, vec3_t result)
{
patch_t *p1, *p2, *p3;
vec3_t base, d1, d2;
vec_t x, y, x1, y1, x2, y2;
int i;
p1 = trian->points[t->edges[0]->p0];
p2 = trian->points[t->edges[1]->p0];
p3 = trian->points[t->edges[2]->p0];
VectorCopy( p1->totallight, base );
VectorSubtract( p2->totallight, base, d1 );
VectorSubtract( p3->totallight, base, d2 );
x = DotProduct (point, t->edges[0]->normal) - t->edges[0]->dist;
y = DotProduct (point, t->edges[2]->normal) - t->edges[2]->dist;
x1 = 0;
y1 = DotProduct (p2->origin, t->edges[2]->normal) - t->edges[2]->dist;
x2 = DotProduct (p3->origin, t->edges[0]->normal) - t->edges[0]->dist;
y2 = 0;
#ifdef BROKEN_CODE
if (fabs(y1)<ON_EPSILON || fabs(x2)<ON_EPSILON)
{
VectorCopy( base, result );
}
else
{
for( i=0; i<3; i++ )
result[i] = base[i] + x*d2[i]/x2 + y*d1[i]/y1;
}
#else
VectorCopy( base, result );
if ( fabs(x2) >= ON_EPSILON )
for( i=0; i<3; i++)
result[i] += x*d2[i]/x2;
if ( fabs(y1) >= ON_EPSILON )
for( i=0; i<3; i++)
result[i] += y*d1[i]/y1;
#endif
}
qboolean PointInTriangle (vec3_t point, triangle_t *t)
{
int i;
triedge_t *e;
vec_t d;
for (i=0 ; i<3 ; i++)
{
e = t->edges[i];
d = DotProduct (e->normal, point) - e->dist;
if (d < 0)
return false; // not inside
}
return true;
}
/*
===============
SampleTriangulation
===============
*/
void SampleTriangulation (vec3_t point, triangulation_t *trian, triangle_t **last_tri, vec3_t result)
{
triangle_t *t;
triedge_t *e;
vec_t d, best;
patch_t *p0, *p1;
vec3_t v1, v2;
int i, j;
if (trian->numpoints == 0)
{
VectorFill( result, 0 );
return;
}
if (trian->numpoints == 1)
{
VectorCopy( trian->points[0]->totallight, result );
return;
}
// try the last one that worked first
if (*last_tri)
{
if (PointInTriangle (point, *last_tri))
{
LerpTriangle (trian, *last_tri, point, result);
return;
}
}
// search for triangles
for (t = trian->tris, j=0 ; j < trian->numtris ; t++, j++)
{
if (t == *last_tri)
continue;
if (!PointInTriangle (point, t))
continue;
// this is it
*last_tri = t;
LerpTriangle (trian, t, point, result);
return;
}
// search for exterior edge
for (e=trian->edges, j=0 ; j< trian->numedges ; e++, j++)
{
if (e->tri)
continue; // not an exterior edge
d = DotProduct (point, e->normal) - e->dist;
if (d < 0)
continue; // not in front of edge
p0 = trian->points[e->p0];
p1 = trian->points[e->p1];
VectorSubtract (p1->origin, p0->origin, v1);
VectorNormalize (v1);
VectorSubtract (point, p0->origin, v2);
d = DotProduct (v2, v1);
if (d < 0)
continue;
if (d > 1)
continue;
for( i=0; i<3; i++ )
result[i] = p0->totallight[i] + d * (p1->totallight[i] - p0->totallight[i]);
return;
}
// search for nearest point
best = 99999;
p1 = NULL;
for (j=0 ; j<trian->numpoints ; j++)
{
p0 = trian->points[j];
VectorSubtract (point, p0->origin, v1);
d = (float)VectorLength (v1);
if (d < best)
{
best = d;
p1 = p0;
}
}
if (!p1)
Error ("SampleTriangulation: no points");
VectorCopy( p1->totallight, result );
}
/*
=================================================================
LIGHTMAP SAMPLE GENERATION
=================================================================
*/
#define SINGLEMAP (18*18*4)
typedef struct
{
vec3_t lightmaps[MAXLIGHTMAPS][SINGLEMAP];
int numlightstyles;
vec_t *light;
vec_t facedist;
vec3_t facenormal;
int numsurfpt;
vec3_t surfpt[SINGLEMAP];
vec3_t facemid; // world coordinates of center
vec3_t texorg;
vec3_t worldtotex[2]; // s = (world - texorg) . worldtotex[0]
vec3_t textoworld[2]; // world = texorg + s * textoworld[0]
vec_t exactmins[2], exactmaxs[2];
int texmins[2], texsize[2];
int lightstyles[256];
int surfnum;
dface_t *face;
} lightinfo_t;
/*
================
CalcFaceExtents
Fills in s->texmins[] and s->texsize[]
also sets exactmins[] and exactmaxs[]
================
*/
void CalcFaceExtents (lightinfo_t *l)
{
dface_t *s;
vec_t mins[2], maxs[2], val;
int i,j, e;
dvertex_t *v;
texinfo_t *tex;
s = l->face;
mins[0] = mins[1] = 999999;
maxs[0] = maxs[1] = -99999;
tex = &texinfo[s->texinfo];
for (i=0 ; i<s->numedges ; i++)
{
e = dsurfedges[s->firstedge+i];
if (e >= 0)
v = dvertexes + dedges[e].v[0];
else
v = dvertexes + dedges[-e].v[1];
for (j=0 ; j<2 ; j++)
{
val = v->point[0] * tex->vecs[j][0] +
v->point[1] * tex->vecs[j][1] +
v->point[2] * tex->vecs[j][2] +
tex->vecs[j][3];
if (val < mins[j])
mins[j] = val;
if (val > maxs[j])
maxs[j] = val;
}
}
for (i=0 ; i<2 ; i++)
{
l->exactmins[i] = mins[i];
l->exactmaxs[i] = maxs[i];
mins[i] = (float)floor(mins[i]/16);
maxs[i] = (float)ceil(maxs[i]/16);
l->texmins[i] = (int)mins[i];
l->texsize[i] = (int)(maxs[i] - mins[i]);
if (l->texsize[i] > 17)
Error ("Bad surface extents");
}
}
/*
================
CalcFaceVectors
Fills in texorg, worldtotex. and textoworld
================
*/
void CalcFaceVectors (lightinfo_t *l)
{
texinfo_t *tex;
int i, j;
vec3_t texnormal;
vec_t distscale;
vec_t dist, len;
tex = &texinfo[l->face->texinfo];
// convert from float to double
for (i=0 ; i<2 ; i++)
for (j=0 ; j<3 ; j++)
l->worldtotex[i][j] = tex->vecs[i][j];
// calculate a normal to the texture axis. points can be moved along this
// without changing their S/T
texnormal[0] = tex->vecs[1][1]*tex->vecs[0][2]
- tex->vecs[1][2]*tex->vecs[0][1];
texnormal[1] = tex->vecs[1][2]*tex->vecs[0][0]
- tex->vecs[1][0]*tex->vecs[0][2];
texnormal[2] = tex->vecs[1][0]*tex->vecs[0][1]
- tex->vecs[1][1]*tex->vecs[0][0];
VectorNormalize (texnormal);
// flip it towards plane normal
distscale = DotProduct (texnormal, l->facenormal);
if (!distscale)
Error ("Texture axis perpendicular to face");
if (distscale < 0)
{
distscale = -distscale;
VectorSubtract (vec3_origin, texnormal, texnormal);
}
// distscale is the ratio of the distance along the texture normal to
// the distance along the plane normal
distscale = 1/distscale;
for (i=0 ; i<2 ; i++)
{
len = (float)VectorLength (l->worldtotex[i]);
dist = DotProduct (l->worldtotex[i], l->facenormal);
dist *= distscale;
VectorMA (l->worldtotex[i], -dist, texnormal, l->textoworld[i]);
VectorScale (l->textoworld[i], (1/len)*(1/len), l->textoworld[i]);
}
// calculate texorg on the texture plane
for (i=0 ; i<3 ; i++)
l->texorg[i] = -tex->vecs[0][3]* l->textoworld[0][i] - tex->vecs[1][3] * l->textoworld[1][i];
// project back to the face plane
dist = DotProduct (l->texorg, l->facenormal) - l->facedist - 1;
dist *= distscale;
VectorMA (l->texorg, -dist, texnormal, l->texorg);
}
/*
=================
CalcPoints
For each texture aligned grid point, back project onto the plane
to get the world xyz value of the sample point
=================
*/
void CalcPoints (lightinfo_t *l)
{
int i;
int s, t, j;
int w, h, step;
vec_t starts, startt, us, ut;
vec_t *surf;
vec_t mids, midt;
vec3_t origin;
surf = l->surfpt[0];
mids = (l->exactmaxs[0] + l->exactmins[0])/2;
midt = (l->exactmaxs[1] + l->exactmins[1])/2;
for (j=0 ; j<3 ; j++)
l->facemid[j] = l->texorg[j] + l->textoworld[0][j]*mids + l->textoworld[1][j]*midt;
h = l->texsize[1]+1;
w = l->texsize[0]+1;
starts = (float)l->texmins[0]*16;
startt = (float)l->texmins[1]*16;
step = 16;
l->numsurfpt = w * h;
// get the origin offset for rotating bmodels
VectorCopy (face_offset[l->surfnum], origin);
for (t=0 ; t<h ; t++)
{
for (s=0 ; s<w ; s++, surf+=3)
{
us = starts + s*step;
ut = startt + t*step;
// if a line can be traced from surf to facemid, the point is good
for (i=0 ; i<64; i++)
{
// calculate texture point
dleaf_t *luxelleaf;
for (j=0 ; j<3 ; j++)
surf[j] = l->texorg[j] + l->textoworld[0][j]*us
+ l->textoworld[1][j]*ut;
VectorAdd (surf, origin, surf);
luxelleaf = PointInLeaf(surf);
// Make sure we are "in the world"(Not the zero leaf)
if ( luxelleaf != dleafs )
{
#if defined(BUGGY_TEST)
if (TestLine_r (0, l->facemid, surf) == CONTENTS_EMPTY)
#endif
break; // got it
}
// nudge it
if (i & 1)
{
if (us > mids)
{
us -= 8;
if (us < mids)
us = mids;
}
else
{
us += 8;
if (us > mids)
us = mids;
}
}
else
{
if (ut > midt)
{
ut -= 8;
if (ut < midt)
ut = midt;
}
else
{
ut += 8;
if (ut > midt)
ut = midt;
}
}
}
}
}
}
//==============================================================
typedef struct
{
vec3_t pos;
vec3_t light;
} sample_t;
typedef struct
{
int numsamples;
sample_t *samples[MAXLIGHTMAPS];
} facelight_t;
directlight_t *directlights[MAX_MAP_LEAFS];
facelight_t facelight[MAX_MAP_FACES];
int numdlights;
/*
==================
FindTargetEntity
==================
*/
entity_t *FindTargetEntity (char *target)
{
int i;
char *n;
for (i=0 ; i<num_entities ; i++)
{
n = ValueForKey (&entities[i], "targetname");
if (!strcmp (n, target))
return &entities[i];
}
return NULL;
}
/*
=============
CreateDirectLights
=============
*/
#define DIRECT_SCALE 0.1f
void CreateDirectLights (void)
{
unsigned i;
patch_t *p;
directlight_t *dl;
dleaf_t *leaf;
int leafnum;
entity_t *e, *e2;
char *name;
char *target;
float angle;
vec3_t dest;
numdlights = 0;
//
// surfaces
//
for (i=0, p=patches ; i<num_patches ; i++, p++)
{
if( VectorAvg( p->totallight ) >= dlight_threshold )
{
numdlights++;
dl = calloc(1, sizeof(directlight_t));
VectorCopy (p->origin, dl->origin);
leaf = PointInLeaf (dl->origin);
leafnum = leaf - dleafs;
dl->next = directlights[leafnum];
directlights[leafnum] = dl;
dl->type = emit_surface;
VectorCopy (p->normal, dl->normal);
VectorCopy( p->totallight, dl->intensity );
VectorScale( dl->intensity, p->area, dl->intensity );
VectorScale( dl->intensity, DIRECT_SCALE, dl->intensity );
}
VectorFill( p->totallight, 0 ); // all sent now // BUGBUG for progressive refinement runs
}
//
// entities
//
for (i=0 ; i<(unsigned)num_entities ; i++)
{
char *pLight;
double r, g, b, scaler;
float l1;
int argCnt;
e = &entities[i];
name = ValueForKey (e, "classname");
if (strncmp (name, "light", 5))
continue;
numdlights++;
dl = calloc(1, sizeof(directlight_t));
GetVectorForKey (e, "origin", dl->origin);
leaf = PointInLeaf (dl->origin);
leafnum = leaf - dleafs;
dl->next = directlights[leafnum];
directlights[leafnum] = dl;
dl->style = (int)FloatForKey (e, "style");
pLight = ValueForKey( e, "_light" );
// scanf into doubles, then assign, so it is vec_t size independent
r = g = b = scaler = 0;
argCnt = sscanf ( pLight, "%lf %lf %lf %lf", &r, &g, &b, &scaler );
dl->intensity[0] = (float)r;
if( argCnt == 1 )
{
// The R,G,B values are all equal.
dl->intensity[1] = dl->intensity[2] = (float)r;
}
else if ( argCnt == 3 || argCnt == 4 )
{
// Save the other two G,B values.
dl->intensity[1] = (float)g;
dl->intensity[2] = (float)b;
// Did we also get an "intensity" scaler value too?
if ( argCnt == 4 )
{
// Scale the normalized 0-255 R,G,B values by the intensity scaler
dl->intensity[0] = dl->intensity[0] / 255 * (float)scaler;
dl->intensity[1] = dl->intensity[1] / 255 * (float)scaler;
dl->intensity[2] = dl->intensity[2] / 255 * (float)scaler;
}
}
else
{
printf( "entity at (%f,%f,%f) has bad '_light' value : '%s'\n",
dl->origin[0], dl->origin[1], dl->origin[2], pLight);
continue;
}
target = ValueForKey (e, "target");
if (!strcmp (name, "light_spot") || !strcmp(name, "light_environment") || target[0])
{
if (!VectorAvg( dl->intensity ))
VectorFill( dl->intensity, 500 );
dl->type = emit_spotlight;
dl->stopdot = FloatForKey (e, "_cone");
if (!dl->stopdot)
dl->stopdot = 10;
dl->stopdot2 = FloatForKey (e, "_cone2");
if (!dl->stopdot2)
dl->stopdot2 = dl->stopdot;
if (dl->stopdot2 < dl->stopdot)
dl->stopdot2 = dl->stopdot;
dl->stopdot2 = (float)cos(dl->stopdot2/180*Q_PI);
dl->stopdot = (float)cos(dl->stopdot/180*Q_PI);
if (target[0])
{ // point towards target
e2 = FindTargetEntity (target);
if (!e2)
printf ("WARNING: light at (%i %i %i) has missing target\n",
(int)dl->origin[0], (int)dl->origin[1], (int)dl->origin[2]);
else
{
GetVectorForKey (e2, "origin", dest);
VectorSubtract (dest, dl->origin, dl->normal);
VectorNormalize (dl->normal);
}
}
else
{ // point down angle
vec3_t vAngles;
GetVectorForKey( e, "angles", vAngles );
angle = (float)FloatForKey (e, "angle");
if (angle == ANGLE_UP)
{
dl->normal[0] = dl->normal[1] = 0;
dl->normal[2] = 1;
}
else if (angle == ANGLE_DOWN)
{
dl->normal[0] = dl->normal[1] = 0;
dl->normal[2] = -1;
}
else
{
// if we don't have a specific "angle" use the "angles" YAW
if ( !angle )
{
angle = vAngles[1];
}
dl->normal[2] = 0;
dl->normal[0] = (float)cos (angle/180*Q_PI);
dl->normal[1] = (float)sin (angle/180*Q_PI);
}
angle = FloatForKey (e, "pitch");
if ( !angle )
{
// if we don't have a specific "pitch" use the "angles" PITCH
angle = vAngles[0];
}
dl->normal[2] = (float)sin(angle/180*Q_PI);
dl->normal[0] *= (float)cos(angle/180*Q_PI);
dl->normal[1] *= (float)cos(angle/180*Q_PI);
}
if (FloatForKey( e, "_sky" ) || !strcmp(name, "light_environment"))
{
dl->type = emit_skylight;
dl->stopdot2 = FloatForKey( e, "_sky" ); // hack stopdot2 to a sky key number
}
}
else
{
if (!VectorAvg( dl->intensity ))
VectorFill( dl->intensity, 300 );
dl->type = emit_point;
}
if (dl->type != emit_skylight)
{
l1 = max( dl->intensity[0], max( dl->intensity[1], dl->intensity[2] ) );
l1 = l1 * l1 / 10;
dl->intensity[0] *= l1;
dl->intensity[1] *= l1;
dl->intensity[2] *= l1;
}
}
qprintf ("%i direct lights\n", numdlights);
}
/*
=============
DeleteDirectLights
=============
*/
void DeleteDirectLights(void)
{
int l;
directlight_t *dl;
for ( l = 0; l < numleafs; l++ )
while ( dl = directlights[l] )
{
directlights[l] = dl->next;
free(dl);
}
}
/*
=============
GatherSampleLight
=============
*/
#define NUMVERTEXNORMALS 162
float r_avertexnormals[NUMVERTEXNORMALS][3] = {
#include "..\..\engine\anorms.h"
};
#define VectorMaximum(a) ( max( (a)[0], max( (a)[1], (a)[2] ) ) )
void GatherSampleLight (vec3_t pos, byte *pvs, vec3_t normal, vec3_t *sample, byte *styles)
{
int i;
directlight_t *l;
vec3_t add;
vec3_t delta;
float dot, dot2;
float dist;
float ratio;
int style_index;
directlight_t *sky_used = NULL;
for (i = 1 ; i<numleafs ; i++)
{
if ( (l = directlights[i]) && (pvs[ (i-1)>>3] & (1<<((i-1)&7))) )
{
for (; l ; l=l->next)
{
// skylights work fundamentally differently than normal lights
if (l->type == emit_skylight)
{
// only allow one of each sky type to hit any given point
if (sky_used)
continue;
sky_used = l;
// make sure the angle is okay
dot = -DotProduct( normal, l->normal );
if (dot <= ON_EPSILON/10)
continue;
// search back to see if we can hit a sky brush
VectorScale( l->normal, -10000, delta );
VectorAdd( pos, delta, delta );
if (TestLine_r (0, pos, delta) != CONTENTS_SKY)
continue; // occluded
VectorScale(l->intensity, dot, add);
}
else
{
VectorSubtract (l->origin, pos, delta);
dist = VectorNormalize (delta);
dot = DotProduct (delta, normal);
if (dot <= ON_EPSILON/10)
continue; // behind sample surface
if (dist < 1.0)
dist = 1.0;
switch (l->type)
{
case emit_point:
ratio = dot / (dist * dist);
VectorScale(l->intensity, ratio, add);
break;
case emit_surface:
dot2 = -DotProduct (delta, l->normal);
if (dot2 <= ON_EPSILON/10)
continue; // behind light surface
ratio = dot * dot2 / (dist * dist);
VectorScale(l->intensity, ratio, add);
break;
case emit_spotlight:
dot2 = -DotProduct (delta, l->normal);
if (dot2 <= l->stopdot2)
continue; // outside light cone
ratio = dot * dot2 / (dist * dist);
if (dot2 <= l->stopdot)
ratio *= (dot2 - l->stopdot2) / (l->stopdot - l->stopdot2);
VectorScale(l->intensity, ratio, add);
break;
default:
Error ("Bad l->type");
}
}
if( VectorMaximum( add ) > ( l->style ? coring : 0 ) )
{
if ( l->type != emit_skylight && TestLine_r (0, pos, l->origin) != CONTENTS_EMPTY )
continue; // occluded
for( style_index = 0; style_index < MAXLIGHTMAPS; style_index++ )
if ( styles[style_index] == l->style || styles[style_index] == 255 )
break;
if ( style_index == MAXLIGHTMAPS )
{
printf ("WARNING: Too many direct light styles on a face(%f,%f,%f)\n",
pos[0], pos[1], pos[2] );
continue;
}
if ( styles[style_index] == 255 )
styles[style_index] = l->style;
VectorAdd( sample[style_index], add, sample[style_index] );
}
}
}
}
if (sky_used && indirect_sun != 0.0)
{
vec3_t total;
int j;
vec3_t sky_intensity;
VectorScale( sky_used->intensity, indirect_sun / (NUMVERTEXNORMALS * 2), sky_intensity );
total[0] = total[1] = total[2] = 0.0;
for (j = 0; j < NUMVERTEXNORMALS; j++)
{
// make sure the angle is okay
dot = -DotProduct( normal, r_avertexnormals[j] );
if (dot <= ON_EPSILON/10)
continue;
// search back to see if we can hit a sky brush
VectorScale( r_avertexnormals[j], -10000, delta );
VectorAdd( pos, delta, delta );
if (TestLine_r (0, pos, delta) != CONTENTS_SKY)
continue; // occluded
VectorScale(sky_intensity, dot, add);
VectorAdd(total, add, total);
}
if( VectorMaximum( total ) > 0 )
{
for( style_index = 0; style_index < MAXLIGHTMAPS; style_index++ )
if ( styles[style_index] == sky_used->style || styles[style_index] == 255 )
break;
if ( style_index == MAXLIGHTMAPS )
{
printf ("WARNING: Too many direct light styles on a face(%f,%f,%f)\n",
pos[0], pos[1], pos[2] );
return;
}
if ( styles[style_index] == 255 )
styles[style_index] = sky_used->style;
VectorAdd( sample[style_index], total, sample[style_index] );
}
}
}
/*
=============
AddSampleToPatch
Take the sample's collected light and
add it back into the apropriate patch
for the radiosity pass.
=============
*/
void AddSampleToPatch (sample_t *s, int facenum)
{
patch_t *patch;
vec3_t mins, maxs;
int i;
if (numbounce == 0)
return;
if( VectorAvg( s->light ) < 1)
return;
for (patch = face_patches[facenum] ; patch ; patch=patch->next)
{
// see if the point is in this patch (roughly)
WindingBounds (patch->winding, mins, maxs);
for (i=0 ; i<3 ; i++)
{
if (mins[i] > s->pos[i] + 16)
goto nextpatch;
if (maxs[i] < s->pos[i] - 16)
goto nextpatch;
}
// add the sample to the patch
patch->samples++;
VectorAdd( patch->samplelight, s->light, patch->samplelight );
//return;
nextpatch:;
}
// don't worry if some samples don't find a patch
}
void
GetPhongNormal( int facenum, vec3_t spot, vec3_t phongnormal )
{
int j;
dface_t *f = dfaces + facenum;
dplane_t *p = dplanes + f->planenum;
vec3_t facenormal;
VectorCopy( p->normal, facenormal );
if ( f->side )
VectorSubtract( vec3_origin, facenormal, facenormal );
VectorCopy( facenormal, phongnormal );
if ( smoothing_threshold != 0 )
{
// Calculate modified point normal for surface
// Use the edge normals iff they are defined. Bend the surface towards the edge normal(s)
// Crude first attempt: find nearest edge normal and do a simple interpolation with facenormal.
// Second attempt: find edge points+center that bound the point and do a three-point triangulation(baricentric)
// Better third attempt: generate the point normals for all vertices and do baricentric triangulation.
for (j=0 ; j<f->numedges ; j++)
{
vec3_t p1, p2, v1, v2, vspot;
int e = dsurfedges[f->firstedge + j];
int e1 = dsurfedges[f->firstedge + ((j-1)%f->numedges)];
int e2 = dsurfedges[f->firstedge + ((j+1)%f->numedges)];
vec3_t n1, n2;
edgeshare_t *es = &edgeshare[abs(e)];
edgeshare_t *es1 = &edgeshare[abs(e1)];
edgeshare_t *es2 = &edgeshare[abs(e2)];
dface_t *f2;
float a, a1, a2, d1, d2, aa, bb, ab;
if ( es->coplanar && es1->coplanar && es2->coplanar
|| VectorCompare(es->interface_normal, vec3_origin)
&& VectorCompare(es1->interface_normal, vec3_origin)
&& VectorCompare(es2->interface_normal, vec3_origin) )
continue;
if (e > 0)
{
f2 = es->faces[1];
VectorCopy( dvertexes[dedges[e].v[0]].point, p1 );
VectorCopy( dvertexes[dedges[e].v[1]].point, p2 );
}
else
{
f2 = es->faces[0];
VectorCopy( dvertexes[dedges[-e].v[1]].point, p1 );
VectorCopy( dvertexes[dedges[-e].v[0]].point, p2 );
}
// Build vectors from the middle of the face to the edge vertexes and the sample pos.
VectorSubtract( p1, face_centroids[facenum], v1 );
VectorSubtract( p2, face_centroids[facenum], v2 );
VectorSubtract( spot, face_centroids[facenum], vspot );
aa = DotProduct( v1, v1 );
bb = DotProduct( v2, v2 );
ab = DotProduct( v1, v2 );
a1 = (bb * DotProduct( v1, vspot ) - ab * DotProduct( vspot, v2 )) / (aa * bb - ab * ab);
a2 = (DotProduct( vspot, v2 ) - a1 * ab) / bb;
// Test center to sample vector for inclusion between center to vertex vectors (Use dot product of vectors)
if ( a1 >= 0.0 && a2 >= 0.0)
{
// calculate distance from edge to pos
vec3_t temp;
VectorAdd( es->interface_normal, es1->interface_normal, n1 );
if ( VectorCompare( n1, vec3_origin ) )
VectorCopy( facenormal, n1 );
VectorNormalize(n1);
VectorAdd( es->interface_normal, es2->interface_normal, n2 );
if ( VectorCompare( n2, vec3_origin ) )
VectorCopy( facenormal, n2 );
VectorNormalize(n2);
// Interpolate between the center and edge normals based on sample position
VectorScale( facenormal, 1.0 - a1 - a2, phongnormal );
VectorScale( n1, a1, temp );
VectorAdd( phongnormal, temp, phongnormal );
VectorScale( n2, a2, temp );
VectorAdd( phongnormal, temp, phongnormal );
VectorNormalize( phongnormal );
break;
}
}
}
}
/*
=============
BuildFacelights
=============
*/
void BuildFacelights (int facenum)
{
dface_t *f;
vec3_t sampled[MAXLIGHTMAPS];
lightinfo_t l;
int i, j, k;
sample_t *s;
float *spot;
patch_t *patch;
byte pvs[(MAX_MAP_LEAFS+7)/8];
int thisoffset = -1, lastoffset = -1;
int lightmapwidth, lightmapheight, size;
vec3_t centroid = { 0, 0, 0 };
f = &dfaces[facenum];
//
// some surfaces don't need lightmaps
//
f->lightofs = -1;
for (j=0 ; j<MAXLIGHTMAPS ; j++)
f->styles[j] = 255;
if ( texinfo[f->texinfo].flags & TEX_SPECIAL)
return; // non-lit texture
f->styles[0] = 0; // Everyone gets the style zero map.
memset (&l, 0, sizeof(l));
l.surfnum = facenum;
l.face = f;
//
// rotate plane
//
VectorCopy (dplanes[f->planenum].normal, l.facenormal);
l.facedist = dplanes[f->planenum].dist;
if (f->side)
{
VectorSubtract (vec3_origin, l.facenormal, l.facenormal);
l.facedist = -l.facedist;
}
CalcFaceVectors (&l);
CalcFaceExtents (&l);
CalcPoints (&l);
lightmapwidth = l.texsize[0]+1;
lightmapheight = l.texsize[1]+1;
size = lightmapwidth*lightmapheight;
if (size > SINGLEMAP)
Error ("Bad lightmap size");
facelight[facenum].numsamples = l.numsurfpt;
for (k=0 ; k<MAXLIGHTMAPS; k++)
facelight[facenum].samples[k] = calloc(l.numsurfpt, sizeof(sample_t));
spot = l.surfpt[0];
for (i=0 ; i<l.numsurfpt ; i++, spot += 3)
{
vec3_t pointnormal = {0,0,0};
for (k=0 ; k<MAXLIGHTMAPS; k++)
VectorCopy (spot, facelight[facenum].samples[k][i].pos);
// get the PVS for the pos to limit the number of checks
if (!visdatasize)
{
memset (pvs, 255, (numleafs+7)/8 );
lastoffset = -1;
}
else
{
dleaf_t *leaf = PointInLeaf( spot );
thisoffset = leaf->visofs;
if ( i == 0 || thisoffset != lastoffset )
{
if (thisoffset == -1)
Error ("leaf->visofs == -1");
DecompressVis (&dvisdata[leaf->visofs], pvs);
}
lastoffset = thisoffset;
}
for( j = 0; j < MAXLIGHTMAPS; j++)
VectorFill( sampled[j], 0 );
// If we are doing "extra" samples, oversample the direct light around the point.
if ( extra )
{
int weighting[3][3] = { { 5, 9, 5 }, { 9, 16, 9 }, { 5, 9, 5 } };
vec3_t pos;
int s, t, subsamples = 0;
for ( t = -1; t <= 1; t ++ )
{
for ( s = -1; s <= 1; s++ )
{
int subsample = i + t * lightmapwidth + s;
int sample_s = i % lightmapwidth;
int sample_t = i / lightmapwidth;
if ( (0 <= s+sample_s) && (s+sample_s < lightmapwidth)
&& (0 <= t+sample_t) && (t+sample_t < lightmapheight) )
{
vec3_t subsampled[MAXLIGHTMAPS];
for( j = 0; j < MAXLIGHTMAPS; j++)
VectorFill( subsampled[j], 0 );
// Calculate the point one third of the way toward the "subsample point"
VectorCopy( l.surfpt[i], pos );
VectorAdd( pos, l.surfpt[i], pos );
VectorAdd( pos, l.surfpt[subsample], pos );
VectorScale( pos, 1.0/3.0, pos );
GetPhongNormal( facenum, pos, pointnormal );
GatherSampleLight( pos, pvs, pointnormal, subsampled, f->styles );
for( j = 0; j < MAXLIGHTMAPS && (f->styles[j] != 255); j++)
{
VectorScale( subsampled[j], weighting[s+1][t+1], subsampled[j] );
VectorAdd( sampled[j], subsampled[j], sampled[j] );
}
subsamples += weighting[s+1][t+1];
}
}
}
for( j=0; j < MAXLIGHTMAPS && (f->styles[j] != 255); j++ )
VectorScale( sampled[j], 1.0/subsamples, sampled[j] );
}
else
{
GetPhongNormal( facenum, spot, pointnormal );
GatherSampleLight( spot, pvs, pointnormal, sampled, f->styles );
}
for( j=0; j < MAXLIGHTMAPS && (f->styles[j] != 255); j++ )
{
VectorCopy (sampled[j], facelight[facenum].samples[j][i].light );
if ( f->styles[j] == 0 )
{
AddSampleToPatch ( &facelight[facenum].samples[j][i], facenum);
}
}
}
// average up the direct light on each patch for radiosity
if (numbounce > 0)
{
for (patch = face_patches[facenum] ; patch ; patch=patch->next)
{
if (patch->samples)
{
vec3_t v; // BUGBUG: Use a weighted average instead?
VectorScale( patch->samplelight, (1.0f/patch->samples), v );
VectorAdd( patch->totallight, v, patch->totallight );
VectorAdd( patch->directlight, v, patch->directlight );
}
}
}
// add an ambient term if desired
if (ambient[0] || ambient[1] || ambient[2])
{
for( j=0; j < MAXLIGHTMAPS && f->styles[j] != 255; j++ )
{
if ( f->styles[j] == 0 )
{
s = facelight[facenum].samples[j];
for (i=0 ; i<l.numsurfpt ; i++, s++)
VectorAdd(s->light, ambient, s->light);
break;
}
}
}
// light from dlight_threshold and above is sent out, but the
// texture itself should still be full bright
// if( VectorAvg( face_patches[facenum]->baselight ) >= dlight_threshold) // Now all lighted surfaces glow
{
for( j=0; j < MAXLIGHTMAPS && f->styles[j] != 255; j++ )
{
if ( f->styles[j] == 0 )
{
s = facelight[facenum].samples[j];
for (i=0 ; i<l.numsurfpt ; i++, s++)
VectorAdd( s->light, face_patches[facenum]->baselight, s->light );
break;
}
}
}
}
/*
=============
ProgressiveRefinement
Progressive mesh refinement of the patches
=============
*/
int
ProgressiveRefinement()
{
return 0;
}
/*
=============
PrecompLightmapOffsets
=============
*/
void
PrecompLightmapOffsets()
{
int facenum;
dface_t *f;
patch_t *patch;
facelight_t *fl;
int lightstyles;
lightdatasize = 0;
for( facenum = 0; facenum < numfaces; facenum++ )
{
f = &dfaces[facenum];
fl = &facelight[facenum];
if ( texinfo[f->texinfo].flags & TEX_SPECIAL)
continue; // non-lit texture
for (lightstyles=0; lightstyles < MAXLIGHTMAPS; lightstyles++ )
if ( f->styles[lightstyles] == 255 )
break;
if ( !lightstyles )
continue;
f->lightofs = lightdatasize;
lightdatasize += fl->numsamples * 3 * lightstyles;
}
}
/*
=============
FinalLightFace
Add the indirect lighting on top of the direct
lighting and save into final map format
=============
*/
void FinalLightFace (int facenum)
{
dface_t *f, *f2;
int i, j, k;
vec3_t lb, v;
patch_t *patch;
triangulation_t *trian;
edgeshare_t *es;
int edgenum;
facelight_t *fl;
sample_t *samp;
triangle_t *last_tri;
float minlight;
int lightstyles;
f = &dfaces[facenum];
fl = &facelight[facenum];
if ( texinfo[f->texinfo].flags & TEX_SPECIAL)
return; // non-lit texture
for (lightstyles=0; lightstyles < MAXLIGHTMAPS; lightstyles++ )
if ( f->styles[lightstyles] == 255 )
break;
if ( !lightstyles )
return;
//
// set up the triangulation
//
if (numbounce > 0)
{
trian = AllocTriangulation (&dplanes[f->planenum]);
for (patch = face_patches[facenum] ; patch ; patch=patch->next)
AddPatchToTriangulation (patch, trian);
for (j=0 ; j<f->numedges ; j++)
{
edgenum = dsurfedges[f->firstedge + j];
if (edgenum > 0)
{
es = &edgeshare[edgenum];
f2 = es->faces[1];
}
else
{
es = &edgeshare[-edgenum];
f2 = es->faces[0];
}
if (!es->coplanar && VectorCompare(vec3_origin, es->interface_normal) )
continue;
for (patch = face_patches[f2-dfaces] ; patch ; patch=patch->next)
AddPatchToTriangulation (patch, trian);
}
TriangulatePoints (trian);
}
//
// sample the triangulation
//
minlight = FloatForKey (face_entity[facenum], "_minlight") * 128;
for (k=0 ; k < lightstyles; k++ )
{
last_tri = NULL;
samp = fl->samples[k];
for (j=0 ; j<fl->numsamples ; j++, samp++)
{
// Should be a VectorCopy, but we scale by 2 to compensate for an earlier lighting flaw
// Specifically, the directlight contribution was included in the bounced light AND the directlight
// Since many of the levels were built with this assumption, this "fudge factor" compensates for it.
VectorScale( samp->light, 2.0, lb );
if (numbounce > 0 && k == 0 )
{
SampleTriangulation (samp->pos, trian, &last_tri, v);
VectorAdd( lb, v, lb );
}
VectorScale( lb, lightscale, lb );
// clip from the bottom first
for( i=0; i<3; i++ )
if( lb[i] < minlight )
lb[i] = minlight;
// clip from the top
if( lb[0]>maxlight || lb[1]>maxlight || lb[2]>maxlight )
{
// find max value and scale the whole color down;
float max = lb[0] > lb[1] ? lb[0] : lb[1];
max = max > lb[2] ? max : lb[2];
for( i=0; i<3; i++ )
lb[i] = ( lb[i] * maxlight ) / max;
}
// gamma adjust
if (gamma != 1.0)
for( i=0; i<3; i++ )
lb[i] = (float)pow( lb[i] / 256.0f, gamma ) * 256.0f;
dlightdata[f->lightofs + k*fl->numsamples*3 + j*3] = (unsigned char)lb[0];
dlightdata[f->lightofs + k*fl->numsamples*3 + j*3 + 1] = (unsigned char)lb[1];
dlightdata[f->lightofs + k*fl->numsamples*3 + j*3 + 2] = (unsigned char)lb[2];
}
}
if (numbounce > 0)
FreeTriangulation (trian);
}
Reference in New Issue View Git Blame Copy Permalink