lightmap.c

Go to the documentation of this file.

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "lighting.h"
#include "bsp.h"

#define sun_angles          config.sun_angles[config.compile_for_day]
#define sun_normal          config.sun_normal[config.compile_for_day]
#define sun_color           config.sun_color[config.compile_for_day]
#define sun_intensity       config.sun_intensity[config.compile_for_day]
#define sun_ambient_color   config.sun_ambient_color[config.compile_for_day]

vec3_t face_offset[MAX_MAP_FACES];      
typedef struct {
    vec_t   facedist;
    vec3_t  facenormal;

    int     numsurfpt;
    vec3_t  *surfpt;

    vec3_t  modelorg;       
    vec3_t  texorg;
    vec3_t  worldtotex[2];  
    vec3_t  textoworld[2];  
    int     texmins[2], texsize[2];
    dBspSurface_t   *face;
} lightinfo_t;

typedef struct extents_s {
    vec3_t mins, maxs;
    vec3_t center;
    vec2_t stmins, stmaxs;
} extents_t;

static extents_t face_extents[MAX_MAP_FACES];

static void BuildFaceExtents (void)
{
    int k;

    for (k = 0; k < curTile->numfaces; k++) {
        const dBspSurface_t *s = &curTile->faces[k];
        const dBspTexinfo_t *tex = &curTile->texinfo[s->texinfo];

        float *mins = face_extents[s - curTile->faces].mins;
        float *maxs = face_extents[s - curTile->faces].maxs;

        float *center = face_extents[s - curTile->faces].center;

        float *stmins = face_extents[s - curTile->faces].stmins;
        float *stmaxs = face_extents[s - curTile->faces].stmaxs;
        int i;

        VectorSet(mins, 999999, 999999, 999999);
        VectorSet(maxs, -999999, -999999, -999999);

        stmins[0] = stmins[1] = 999999;
        stmaxs[0] = stmaxs[1] = -999999;

        for (i = 0; i < s->numedges; i++) {
            const int e = curTile->surfedges[s->firstedge + i];
            const dBspVertex_t *v;
            int j;

            if (e >= 0)
                v = curTile->vertexes + curTile->edges[e].v[0];
            else
                v = curTile->vertexes + curTile->edges[-e].v[1];

            for (j = 0; j < 3; j++) {  /* calculate mins, maxs */
                if (v->point[j] > maxs[j])
                    maxs[j] = v->point[j];
                if (v->point[j] < mins[j])
                    mins[j] = v->point[j];
            }

            for (j = 0; j < 2; j++) {  /* calculate stmins, stmaxs */
                const float val = DotProduct(v->point, tex->vecs[j]) + tex->vecs[j][3];
                if (val < stmins[j])
                    stmins[j] = val;
                if (val > stmaxs[j])
                    stmaxs[j] = val;
            }
        }

        for (i = 0; i < 3; i++)
            center[i] = (mins[i] + maxs[i]) / 2.0f;
    }
}

static void CalcLightinfoExtents (lightinfo_t *l)
{
    const dBspSurface_t *s;
    float *stmins, *stmaxs;
    vec2_t lm_mins, lm_maxs;
    int i;

    s = l->face;

    stmins = face_extents[s - curTile->faces].stmins;
    stmaxs = face_extents[s - curTile->faces].stmaxs;

    for (i = 0; i < 2; i++) {
        lm_mins[i] = floor(stmins[i] / (1 << config.lightquant));
        lm_maxs[i] = ceil(stmaxs[i] / (1 << config.lightquant));

        l->texmins[i] = lm_mins[i];
        l->texsize[i] = lm_maxs[i] - lm_mins[i];
    }

    if (l->texsize[0] * l->texsize[1] > MAX_MAP_LIGHTMAP)
        Sys_Error("Surface too large to light (%dx%d)", l->texsize[0], l->texsize[1]);
}

static void CalcLightinfoVectors (lightinfo_t *l)
{
    const dBspTexinfo_t *tex;
    int i;
    vec3_t texnormal;
    vec_t distscale, dist;

    tex = &curTile->texinfo[l->face->texinfo];

    /* convert from float to double */
    for (i = 0; i < 2; i++)
        VectorCopy(tex->vecs[i], l->worldtotex[i]);

    /* 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) {
        Verb_Printf(VERB_EXTRA, "WARNING: Texture axis perpendicular to face\n");
        distscale = 1.0;
    }
    if (distscale < 0.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.0 / distscale;

    for (i = 0; i < 2; i++) {
        const vec_t len = VectorLength(l->worldtotex[i]);
        const vec_t distance = DotProduct(l->worldtotex[i], l->facenormal) * distscale;
        VectorMA(l->worldtotex[i], -distance, texnormal, l->textoworld[i]);
        VectorScale(l->textoworld[i], (1.0f / len) * (1.0f / 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);

    /* compensate for org'd bmodels */
    VectorAdd(l->texorg, l->modelorg, l->texorg);

    /* total sample count */
    l->numsurfpt = (l->texsize[0] + 1) * (l->texsize[1] + 1);
    l->surfpt = Mem_Alloc(l->numsurfpt * sizeof(vec3_t));
    if (!l->surfpt)
        Sys_Error("Surface too large to light ("UFO_SIZE_T")", l->numsurfpt * sizeof(*l->surfpt));
}

static void CalcPoints (lightinfo_t *l, float sofs, float tofs)
{
    int s, t, j;
    int w, h, step;
    vec_t starts, startt;
    vec_t *surf;

    /* fill in surforg
     * the points are biased towards the center of the surfaces
     * to help avoid edge cases just inside walls */
    surf = l->surfpt[0];

    h = l->texsize[1] + 1;
    w = l->texsize[0] + 1;

    step = 1 << config.lightquant;
    starts = l->texmins[0] * step;
    startt = l->texmins[1] * step;

    for (t = 0; t < h; t++) {
        for (s = 0; s < w; s++, surf += 3) {
            const vec_t us = starts + (s + sofs) * step;
            const vec_t ut = startt + (t + tofs) * step;

            /* calculate texture point */
            for (j = 0; j < 3; j++)
                surf[j] = l->texorg[j] + l->textoworld[0][j] * us +
                        l->textoworld[1][j] * ut;
        }
    }
}

typedef struct facelight_s {
    int numsamples;
    float *origins;
    float *samples;     
    float *directions;  
} facelight_t;

static facelight_t facelight[LIGHTMAP_MAX][MAX_MAP_FACES];

typedef enum {
    emit_surface,       
    emit_point,         
    emit_spotlight      
} emittype_t;

typedef struct light_s {
    struct light_s *next;   
    emittype_t  type;       
    float       intensity;  
    vec3_t      origin;     
    vec3_t      color;      
    vec3_t      normal;     
    float       stopdot;    
} light_t;

static light_t *lights[LIGHTMAP_MAX];
static int numlights[LIGHTMAP_MAX];

void BuildLights (void)
{
    int i;
    light_t *l;

    /* surfaces */
    for (i = 0; i < MAX_MAP_FACES; i++) {
        const patch_t *p = face_patches[i];
        while (p) {  /* iterate subdivided patches */
            if (VectorCompare(p->light, vec3_origin))
                continue;

            numlights[config.compile_for_day]++;
            l = Mem_Alloc(sizeof(*l));

            VectorCopy(p->origin, l->origin);

            l->next = lights[config.compile_for_day];
            lights[config.compile_for_day] = l;

            l->type = emit_surface;

            l->intensity = ColorNormalize(p->light, l->color);
            l->intensity *= p->area * config.surface_scale;

            p = p->next;
        }
    }

    /* entities (skip the world) */
    for (i = 1; i < num_entities; i++) {
        float intensity;
        const char *color;
        const char *target;
        const entity_t *e = &entities[i];
        const char *name = ValueForKey(e, "classname");
        if (strncmp(name, "light", 5))
            continue;

        /* remove those lights that are only for the night version */
        if (config.compile_for_day) {
            const int spawnflags = atoi(ValueForKey(e, "spawnflags"));
            if (!(spawnflags & 1))  /* day */
                continue;
        }

        numlights[config.compile_for_day]++;
        l = Mem_Alloc(sizeof(*l));

        GetVectorForKey(e, "origin", l->origin);

        /* link in */
        l->next = lights[config.compile_for_day];
        lights[config.compile_for_day] = l;

        intensity = FloatForKey(e, "light");
        if (!intensity)
            intensity = 300.0;
        color = ValueForKey(e, "_color");
        if (color && color[0] != '\0'){
            sscanf(color, "%f %f %f", &l->color[0], &l->color[1], &l->color[2]);
            ColorNormalize(l->color, l->color);
        } else
            l->color[0] = l->color[1] = l->color[2] = 1.0;
        l->intensity = intensity * config.entity_scale;
        l->type = emit_point;

        target = ValueForKey(e, "target");
        if (target[0] != '\0' || !strcmp(name, "light_spot")) {
            l->type = emit_spotlight;
            l->stopdot = FloatForKey(e, "_cone");
            if (!l->stopdot)
                l->stopdot = 10;
            l->stopdot = cos(l->stopdot * torad);
            if (target[0] != '\0') {    /* point towards target */
                entity_t *e2 = FindTargetEntity(target);
                if (!e2)
                    Com_Printf("WARNING: light at (%i %i %i) has missing target '%s' - e.g. create an info_null that has a 'targetname' set to '%s'\n",
                        (int)l->origin[0], (int)l->origin[1], (int)l->origin[2], target, target);
                else {
                    vec3_t dest;
                    GetVectorForKey(e2, "origin", dest);
                    VectorSubtract(dest, l->origin, l->normal);
                    VectorNormalize(l->normal);
                }
            } else {    /* point down angle */
                const float angle = FloatForKey(e, "angle");
                if (angle == ANGLE_UP) {
                    l->normal[0] = l->normal[1] = 0.0;
                    l->normal[2] = 1.0;
                } else if (angle == ANGLE_DOWN) {
                    l->normal[0] = l->normal[1] = 0.0;
                    l->normal[2] = -1.0;
                } else {
                    l->normal[2] = 0;
                    l->normal[0] = cos(angle * torad);
                    l->normal[1] = sin(angle * torad);
                }
            }
        }
    }

    /* handle worldspawn light settings */
    {
        const entity_t *e = &entities[0];
        const char *ambient, *light, *angles, *color;
        float f;
        int i;

        if (config.compile_for_day) {
            ambient = ValueForKey(e, "ambient_day");
            light = ValueForKey(e, "light_day");
            angles = ValueForKey(e, "angles_day");
            color = ValueForKey(e, "color_day");
        } else {
            ambient = ValueForKey(e, "ambient_night");
            light = ValueForKey(e, "light_night");
            angles = ValueForKey(e, "angles_night");
            color = ValueForKey(e, "color_night");
        }

        if (light[0] != '\0')
            sun_intensity = atoi(light);

        if (angles[0] != '\0') {
            VectorClear(sun_angles);
            sscanf(angles, "%f %f", &sun_angles[0], &sun_angles[1]);
            AngleVectors(sun_angles, sun_normal, NULL, NULL);
        }

        if (color[0] != '\0') {
            GetVectorFromString(color, sun_color);
            ColorNormalize(sun_color, sun_color);
        }

        if (ambient[0] != '\0')
            GetVectorFromString(ambient, sun_ambient_color);

        /* optionally pull brightness from worldspawn */
        f = FloatForKey(e, "brightness");
        if (f > 0.0)
            config.brightness = f;

        /* saturation as well */
        f = FloatForKey(e, "saturation");
        if (f > 0.0)
            config.saturation = f;
        else
            Verb_Printf(VERB_EXTRA, "Invalid saturation setting (%f) in worldspawn found\n", f);

        f = FloatForKey(e, "contrast");
        if (f > 0.0)
            config.contrast = f;
        else
            Verb_Printf(VERB_EXTRA, "Invalid contrast setting (%f) in worldspawn found\n", f);

        /* lightmap resolution downscale (e.g. 4 = 1 << 4) */
        i = atoi(ValueForKey(e, "quant"));
        if (i >= 1 && i <= 6)
            config.lightquant = i;
        else
            Verb_Printf(VERB_EXTRA, "Invalid quant setting (%i) in worldspawn found\n", i);
    }

    Verb_Printf(VERB_EXTRA, "light settings:\n * intensity: %i\n * sun_angles: pitch %f yaw %f\n * sun_color: %f:%f:%f\n * sun_ambient_color: %f:%f:%f\n",
        sun_intensity, sun_angles[0], sun_angles[1], sun_color[0], sun_color[1], sun_color[2], sun_ambient_color[0], sun_ambient_color[1], sun_ambient_color[2]);
    Verb_Printf(VERB_NORMAL, "%i direct lights for %s lightmap\n", numlights[config.compile_for_day], (config.compile_for_day ? "day" : "night"));
}

static qboolean TR_TestLineSingleTile (const vec3_t start, const vec3_t stop, int *headhint)
{
    int i;
    static int shared_lastthead = 0;
    int lastthead = *headhint;

    if (!lastthead) {
        lastthead = shared_lastthead;
        *headhint = lastthead;
    }

    assert(mapTiles.numTiles == 1);

    /* ufo2map does many traces to the same endpoint.
     * Often an occluding node will be found in the same thead
     * as the last trace, so test that one first. */
    if (curTile->theadlevel[lastthead] <= LEVEL_LASTLIGHTBLOCKING
        && TR_TestLine_r(curTile, curTile->thead[lastthead], start, stop))
        return qtrue;

    for (i = 0; i < curTile->numtheads; i++) {
        const int level = curTile->theadlevel[i];
        if (i == lastthead)
            continue;
        if (level > LEVEL_LASTLIGHTBLOCKING)
            continue;
        if (TR_TestLine_r(curTile, curTile->thead[i], start, stop)) {
            shared_lastthead = *headhint = i;
            return qtrue;
        }
    }
    return qfalse;
}

static void GatherSampleSunlight (const vec3_t pos, const vec3_t normal, float *sample, float *direction, float scale, int *headhint)
{
    vec3_t delta;
    float dot, light;

    if (!sun_intensity)
        return;

    dot = DotProduct(sun_normal, normal);
    if (dot <= 0.001)
        return; /* wrong direction */

    /* don't use only 512 (which would be the 8 level max unit) but a
     * higher value - because the light angle is not fixed at 90 degree */
    VectorMA(pos, 8192, sun_normal, delta);

    if (TR_TestLineSingleTile(pos, delta, headhint))
        return; /* occluded */

    light = sun_intensity * dot * scale;

    /* add some light to it */
    VectorMA(sample, light, sun_color, sample);

    /* and accumulate the direction */
    VectorMix(normal, sun_normal, light / sun_intensity, delta);
    VectorMA(direction, light * scale, delta, direction);
}


static void GatherSampleLight (vec3_t pos, const vec3_t normal, float *sample, float *direction, float scale, int *headhints)
{
    light_t *l;
    vec3_t delta;
    float dot, dot2;
    float dist;
    int *headhint;

    for (l = lights[config.compile_for_day], headhint = headhints; l; l = l->next, headhint++) {
        float light = 0.0;

        /* Com_Printf("Looking with next hint.\n"); */

        VectorSubtract(l->origin, pos, delta);
        dist = VectorNormalize(delta);

        dot = DotProduct(delta, normal);
        if (dot <= 0.001)
            continue;   /* behind sample surface */

        switch (l->type) {
        case emit_point:
            /* linear falloff */
            light = (l->intensity - dist) * dot;
            break;

        case emit_surface:
            /* exponential falloff */
            light = (l->intensity / (dist * dist)) * dot;
            break;

        case emit_spotlight:
            /* linear falloff with cone */
            dot2 = -DotProduct(delta, l->normal);
            if (dot2 > l->stopdot) {
                /* inside the cone */
                light = (l->intensity - dist) * dot;
            } else {
                /* outside the cone */
                light = (l->intensity * 0.5 - dist) * dot;
            }
            break;
        default:
            Sys_Error("Bad l->type");
        }

        if (light <= 0.5)  /* almost no light */
            continue;

        if (TR_TestLineSingleTile(pos, l->origin, headhint))
            continue;   /* occluded */

        /* add some light to it */
        VectorMA(sample, light * scale, l->color, sample);

        /* and add some direction */
        VectorMix(normal, delta, 2.0 * light / l->intensity, delta);
        VectorMA(direction, light * scale, delta, direction);
    }

    /* Com_Printf("Looking with last hint.\n"); */
    GatherSampleSunlight(pos, normal, sample, direction, scale, headhint);
}

#define SAMPLE_NUDGE 0.25

static inline void NudgeSamplePosition (const vec3_t in, const vec3_t normal, const vec3_t center, vec3_t out)
{
    vec3_t dir;

    VectorCopy(in, out);

    /* move into the level using the normal and surface center */
    VectorSubtract(out, center, dir);
    VectorNormalize(dir);

    VectorMA(out, SAMPLE_NUDGE, dir, out);
    VectorMA(out, SAMPLE_NUDGE, normal, out);
}

#define MAX_VERT_FACES 256

static void FacesWithVert (int vert, int *faces, int *nfaces)
{
    int i, j, k;

    k = 0;
    for (i = 0; i < curTile->numfaces; i++) {
        const dBspSurface_t *face = &curTile->faces[i];

        if (!(curTile->texinfo[face->texinfo].surfaceFlags & SURF_PHONG))
            continue;

        for (j = 0; j < face->numedges; j++) {
            const int e = curTile->surfedges[face->firstedge + j];
            const int v = e >= 0 ? curTile->edges[e].v[0] : curTile->edges[-e].v[1];

            /* face references vert */
            if (v == vert) {
                faces[k++] = i;
                if (k == MAX_VERT_FACES)
                    Sys_Error("MAX_VERT_FACES");
                break;
            }
        }
    }
    *nfaces = k;
}

void BuildVertexNormals (void)
{
    int vert_faces[MAX_VERT_FACES];
    int num_vert_faces;
    vec3_t norm, delta;
    float scale;
    int i, j;

    BuildFaceExtents();

    for (i = 0; i < curTile->numvertexes; i++) {
        VectorClear(curTile->normals[i].normal);

        FacesWithVert(i, vert_faces, &num_vert_faces);
        if (!num_vert_faces)  /* rely on plane normal only */
            continue;

        for (j = 0; j < num_vert_faces; j++) {
            const dBspSurface_t *face = &curTile->faces[vert_faces[j]];
            const dBspPlane_t *plane = &curTile->planes[face->planenum];

            /* scale the contribution of each face based on size */
            VectorSubtract(face_extents[vert_faces[j]].maxs, face_extents[vert_faces[j]].mins, delta);
            scale = VectorLength(delta);

            if (face->side)
                VectorScale(plane->normal, -scale, norm);
            else
                VectorScale(plane->normal, scale, norm);

            VectorAdd(curTile->normals[i].normal, norm, curTile->normals[i].normal);
        }
        VectorNormalize(curTile->normals[i].normal);
    }
}


static void SampleNormal (const lightinfo_t *l, const vec3_t pos, vec3_t normal)
{
    vec3_t temp;
    float dist[MAX_VERT_FACES];
    float nearest;
    int i, v, nearv;

    nearest = 9999.0;
    nearv = 0;

    /* calculate the distance to each vertex */
    for (i = 0; i < l->face->numedges; i++) {  /* find nearest and farthest verts */
        const int e = curTile->surfedges[l->face->firstedge + i];
        if (e >= 0)
            v = curTile->edges[e].v[0];
        else
            v = curTile->edges[-e].v[1];

        VectorSubtract(pos, curTile->vertexes[v].point, temp);
        dist[i] = VectorLength(temp);
        if (dist[i] < nearest) {
            nearest = dist[i];
            nearv = v;
        }
    }
    VectorCopy(curTile->normals[nearv].normal, normal);
}


#define MAX_SAMPLES 5
static const float sampleofs[MAX_SAMPLES][2] = {
    {0.0, 0.0}, {-0.125, -0.125}, {0.125, -0.125}, {0.125, 0.125}, {-0.125, 0.125}
};

void BuildFacelights (unsigned int facenum)
{
    dBspSurface_t *face;
    dBspPlane_t *plane;
    dBspTexinfo_t *tex;
    float *center;
    float *sdir, *tdir;
    vec3_t normal, binormal;
    vec4_t tangent;
    lightinfo_t l[MAX_SAMPLES];
    float scale;
    int i, j, numsamples;
    facelight_t *fl;
    int *headhints;

    if (facenum >= MAX_MAP_FACES) {
        Com_Printf("MAX_MAP_FACES hit\n");
        return;
    }

    face = &curTile->faces[facenum];
    plane = &curTile->planes[face->planenum];
    tex = &curTile->texinfo[face->texinfo];

    if (tex->surfaceFlags & SURF_WARP)
        return;     /* non-lit texture */

    sdir = tex->vecs[0];
    tdir = tex->vecs[1];

    /* lighting -extra antialiasing */
    if (config.extrasamples)
        numsamples = MAX_SAMPLES;
    else
        numsamples = 1;

    memset(l, 0, sizeof(l));

    scale = 1.0 / numsamples; /* each sample contributes this much */

    for (i = 0; i < numsamples; i++) {
        l[i].face = face;
        l[i].facedist = plane->dist;
        VectorCopy(plane->normal, l[i].facenormal);
        /* negate the normal and dist */
        if (face->side) {
            VectorNegate(l[i].facenormal, l[i].facenormal);
            l[i].facedist = -l[i].facedist;
        }

        /* get the origin offset for rotating bmodels */
        VectorCopy(face_offset[facenum], l[i].modelorg);

        /* calculate lightmap texture mins and maxs */
        CalcLightinfoExtents(&l[i]);

        /* and the lightmap texture vectors */
        CalcLightinfoVectors(&l[i]);

        /* now generate all of the sample points */
        CalcPoints(&l[i], sampleofs[i][0], sampleofs[i][1]);
    }

    fl = &facelight[config.compile_for_day][facenum];
    fl->numsamples = l[0].numsurfpt;

    fl->origins = Mem_Alloc(fl->numsamples * sizeof(vec3_t));
    memcpy(fl->origins, l[0].surfpt, fl->numsamples * sizeof(vec3_t));
    fl->samples = Mem_Alloc(fl->numsamples * sizeof(vec3_t));
    fl->directions = Mem_Alloc(fl->numsamples * sizeof(vec3_t));

    center = face_extents[facenum].center;  /* center of the face */

    /* Also setup the hints.  Each hint is specific to each light source, including sunlight. */
    headhints = Mem_Alloc((numlights[config.compile_for_day] + 1) * sizeof(int));

    /* calculate light for each sample */
    for (i = 0; i < fl->numsamples; i++) {
        float *sample = fl->samples + i * 3;            /* accumulate lighting here */
        float *direction = fl->directions + i * 3;      /* accumulate direction here */

        for (j = 0; j < numsamples; j++) {  /* with antialiasing */
            vec3_t pos;

            if (tex->surfaceFlags & SURF_PHONG)
                /* interpolated normal */
                SampleNormal(&l[0], l[j].surfpt[i], normal);
            else
                /* or just plane normal */
                VectorCopy(l[0].facenormal, normal);

            NudgeSamplePosition(l[j].surfpt[i], normal, center, pos);

            GatherSampleLight(pos, normal, sample, direction, scale, headhints);
        }
        if (!VectorCompare(direction, vec3_origin)) {
            vec3_t dir;

            /* normalize it */
            VectorNormalize(direction);

            /* finalize the lighting direction for the sample */
            TangentVectors(normal, sdir, tdir, tangent, binormal);

            dir[0] = DotProduct(direction, tangent);
            dir[1] = DotProduct(direction, binormal);
            dir[2] = DotProduct(direction, normal);

            VectorCopy(dir, direction);
        }
    }

    /* Free the hints. */
    Mem_Free(headhints);

    for (i = 0; i < l[0].numsurfpt; i++) {  /* pad them */
        float *direction = fl->directions + i * 3;
        if (VectorCompare(direction, vec3_origin))
            VectorSet(direction, 0.0, 0.0, 1.0);
    }

    /* free the sample positions for the face */
    for (i = 0; i < numsamples; i++)
        Mem_Free(l[i].surfpt);
}

static void WriteTGA24 (const char *filename, const byte * data, int width, int height, int offset)
{
    int i, c;
    byte *buffer;
    qFILE file;

    /* allocate a buffer and set it up */
    buffer = Mem_Alloc(width * height * 3 + 18);
    memset(buffer, 0, 18);
    buffer[2] = 2;
    buffer[12] = width & 255;
    buffer[13] = width >> 8;
    buffer[14] = height & 255;
    buffer[15] = height >> 8;
    buffer[16] = 24;

    /* swap rgb to bgr */
    c = (width * height * 3) + 18;
    for (i = 18; i < c; i += 6) {
        buffer[i] = data[i - 18 + offset + 2];  /* blue */
        buffer[i + 1] = data[i - 18 + offset + 1];  /* green */
        buffer[i + 2] = data[i - 18 + offset + 0];  /* red */
    }

    /* write it and free the buffer */
    if (FS_OpenFile(filename, &file, FILE_WRITE) > 0)
        Sys_Error("Unable to open %s for writing", filename);

    FS_Write(buffer, c, &file);

    /* close the file */
    FS_CloseFile(&file);
    Mem_Free(buffer);
}

static void CalcTextureSize (const dBspSurface_t *s, vec2_t texsize, int scale)
{
    const float *stmins = face_extents[s - curTile->faces].stmins;
    const float *stmaxs = face_extents[s - curTile->faces].stmaxs;
    int i;

    for (i = 0; i < 2; i++) {
        const float mins = floor(stmins[i] / scale);
        const float maxs = ceil(stmaxs[i] / scale);

        texsize[i] = maxs - mins;
    }
}

static void ExportLightmap (const char *path, const char *name, qboolean day)
{
    int i;
    const int lightmapIndex = day ? 1 : 0;
    const byte *bspLightBytes = curTile->lightdata[lightmapIndex];
    const byte quant = *bspLightBytes;
    const int scale = 1 << quant;

    for (i = 0; i < curTile->numfaces; i++) {
        const dBspSurface_t *face = &curTile->faces[i];
        const byte *lightmap = bspLightBytes + face->lightofs[lightmapIndex];
        vec2_t texSize;

        CalcTextureSize(face, texSize, scale);

        /* write a tga image out */
        if (texSize[0] && texSize[1]) {
            char filename[MAX_QPATH];
            Com_sprintf(filename, sizeof(filename), "%s/%s_lightmap_%04d%c.tga", path, name, i, day ? 'd' : 'n');
            Com_Printf("Writing %s (%.0fx%.0f)\n", filename, texSize[0], texSize[1]);
            WriteTGA24(filename, lightmap, texSize[0], texSize[1], 0);
            Com_sprintf(filename, sizeof(filename), "%s/%s_direction_%04d%c.tga", path, name, i, day ? 'd' : 'n');
            Com_Printf("Writing %s (%.0fx%.0f)\n", filename, texSize[0], texSize[1]);
            WriteTGA24(filename, lightmap, texSize[0], texSize[1], 3);
        }
    }
}

void ExportLightmaps (const char *bspFileName)
{
    char path[MAX_QPATH], lightmapName[MAX_QPATH];
    const char *fileName = Com_SkipPath(bspFileName);

    Com_FilePath(bspFileName, path);
    Com_StripExtension(fileName, lightmapName, sizeof(lightmapName));

    /* note it */
    Com_Printf("--- ExportLightmaps ---\n");

    BuildFaceExtents();

    ExportLightmap(path, lightmapName, qtrue);
    ExportLightmap(path, lightmapName, qfalse);
}

static const vec3_t luminosity = {0.2125, 0.7154, 0.0721};

void FinalLightFace (unsigned int facenum)
{
    dBspSurface_t *f;
    int j, k;
    vec3_t dir, intensity;
    facelight_t *fl;
    float max, d;
    byte *dest;

    f = &curTile->faces[facenum];
    fl = &facelight[config.compile_for_day][facenum];

    /* none-lit texture */
    if (curTile->texinfo[f->texinfo].surfaceFlags & SURF_WARP)
        return;

    ThreadLock();

    f->lightofs[config.compile_for_day] = curTile->lightdatasize[config.compile_for_day];
    curTile->lightdatasize[config.compile_for_day] += fl->numsamples * 3;
    /* account for light direction data as well */
    curTile->lightdatasize[config.compile_for_day] += fl->numsamples * 3;

    if (curTile->lightdatasize[config.compile_for_day] > MAX_MAP_LIGHTING)
        Sys_Error("MAX_MAP_LIGHTING (%i exceeded %i) - try to reduce the brush size (%s)",
            curTile->lightdatasize[config.compile_for_day], MAX_MAP_LIGHTING,
            curTile->texinfo[f->texinfo].texture);

    ThreadUnlock();

    /* write it out */
    dest = &curTile->lightdata[config.compile_for_day][f->lightofs[config.compile_for_day]];

    for (j = 0; j < fl->numsamples; j++) {
        vec3_t temp;

        /* start with raw sample data */
        VectorCopy((fl->samples + j * 3), temp);

        /* convert to float */
        VectorScale(temp, 1.0 / 255.0, temp);

        /* add an ambient term if desired */
        VectorAdd(temp, sun_ambient_color, temp);

        /* apply global scale factor */
        VectorScale(temp, config.brightness, temp);

        max = 0.0;

        /* find the brightest component */
        for (k = 0; k < 3; k++) {
            /* enforcing positive values */
            if (temp[k] < 0.0)
                temp[k] = 0.0;

            if (temp[k] > max)
                max = temp[k];
        }

        if (max > 255.0)  /* clamp without changing hue */
            VectorScale(temp, 255.0 / max, temp);

        for (k = 0; k < 3; k++) {  /* apply contrast */
            temp[k] -= 0.5;  /* normalize to -0.5 through 0.5 */

            temp[k] *= config.contrast;  /* scale */

            temp[k] += 0.5;

            if (temp[k] > 1.0)  /* clamp */
                temp[k] = 1.0;
            else if (temp[k] < 0)
                temp[k] = 0;
        }

        /* apply saturation */
        d = DotProduct(temp, luminosity);

        VectorSet(intensity, d, d, d);
        VectorMix(intensity, temp, config.saturation, temp);

        for (k = 0; k < 3; k++) {
            temp[k] *= 255.0;  /* back to byte */

            if (temp[k] > 255.0)  /* clamp */
                temp[k] = 255.0;
            else if (temp[k] < 0.0)
                temp[k] = 0.0;

            *dest++ = (byte)temp[k];
        }

        /* also write the directional data */
        VectorCopy((fl->directions + j * 3), dir);
        for (k = 0; k < 3; k++)
            *dest++ = (byte)((dir[k] + 1.0f) * 127.0f);
    }
}