light.c File Reference

#include "sw.h"

Go to the source code of this file.

Functions
static void	R_MarkLights_r (mnode_t *node, dlight_t *light, vec3_t transformed, int bit)
void	R_MarkLights (mnode_t *headnode)
static qboolean	_R_LightPoint (vec3_t start, vec3_t color)
void	R_LightPoint (vec3_t point, vec3_t color)
static void	R_AddDynamicLights (void)
void	R_BuildLightMap (void)

Variables
int	r_dlightframecount
blocklight_t	blocklights [MAX_BLOCKLIGHTS *LIGHTMAP_BYTES]

Function Documentation

_R_LightPoint()

static qboolean _R_LightPoint ( vec3_t  start, vec3_t  color  )

static

Definition at line 106 of file light.c.

{
    mface_t         *surf;
    int             s, t, maps;
    byte            *lightmap;
    byte            *b1, *b2, *b3, *b4;
    int             fracu, fracv;
    int             w1, w2, w3, w4;
    byte            temp[3];
    int             smax, tmax, size;
    float           scale;
    vec3_t          end;
    lightpoint_t    lightpoint;
 
    end[0] = start[0];
    end[1] = start[1];
    end[2] = start[2] - 2048;
 
    BSP_LightPoint(&lightpoint, start, end, r_worldmodel->nodes);
 
    surf = lightpoint.surf;
    if (!surf)
        return qfalse;
 
    fracu = lightpoint.s & 15;
    fracv = lightpoint.t & 15;
 
    // compute weights of lightmap blocks
    w1 = (16 - fracu) * (16 - fracv);
    w2 = fracu * (16 - fracv);
    w3 = fracu * fracv;
    w4 = (16 - fracu) * fracv;
 
    s = lightpoint.s >> 4;
    t = lightpoint.t >> 4;
 
    smax = S_MAX(surf);
    tmax = T_MAX(surf);
    size = smax * tmax * LIGHTMAP_BYTES;
 
    // add all the lightmaps with bilinear filtering
    lightmap = surf->lightmap;
    for (maps = 0; maps < surf->numstyles; maps++) {
        b1 = &lightmap[LIGHTMAP_BYTES * ((t + 0) * smax + (s + 0))];
        b2 = &lightmap[LIGHTMAP_BYTES * ((t + 0) * smax + (s + 1))];
        b3 = &lightmap[LIGHTMAP_BYTES * ((t + 1) * smax + (s + 1))];
        b4 = &lightmap[LIGHTMAP_BYTES * ((t + 1) * smax + (s + 0))];
 
        temp[0] = (w1 * b1[0] + w2 * b2[0] + w3 * b3[0] + w4 * b4[0]) >> 8;
        temp[1] = (w1 * b1[1] + w2 * b2[1] + w3 * b3[1] + w4 * b4[1]) >> 8;
        temp[2] = (w1 * b1[2] + w2 * b2[2] + w3 * b3[2] + w4 * b4[2]) >> 8;
 
        scale = r_newrefdef.lightstyles[surf->styles[maps]].white * (1.0f / 255);
        color[0] += temp[0] * scale;
        color[1] += temp[1] * scale;
        color[2] += temp[2] * scale;
 
        lightmap += size;
    }
 
    return qtrue;
}

Referenced by R_LightPoint().

R_AddDynamicLights()

static void R_AddDynamicLights ( void  )

static

Definition at line 214 of file light.c.

{
    mface_t         *surf;
    dlight_t        *light;
    mtexinfo_t      *tex;
    vec3_t          transformed, impact;
    int             local[2];
    vec_t           dist, rad, minlight, scale, frac;
    blocklight_t    *block;
    int             i, smax, tmax, s, t, sd, td;
 
    surf = r_drawsurf.surf;
    smax = S_MAX(surf);
    tmax = T_MAX(surf);
    tex = surf->texinfo;
 
    for (i = 0; i < r_newrefdef.num_dlights; i++) {
        if (!(surf->dlightbits & (1 << i)))
            continue;
 
        light = &r_newrefdef.dlights[i];
 
        if (currententity && currententity != &r_worldentity) {
            vec3_t      temp;
 
            VectorSubtract(light->origin, currententity->origin, temp);
            transformed[0] = DotProduct(temp, entity_rotation[0]);
            transformed[1] = DotProduct(temp, entity_rotation[1]);
            transformed[2] = DotProduct(temp, entity_rotation[2]);
        } else {
            VectorCopy(light->origin, transformed);
        }
 
        dist = PlaneDiffFast(transformed, surf->plane);
        rad = light->intensity - fabs(dist);
        if (rad < DLIGHT_CUTOFF)
            continue;
        minlight = rad - DLIGHT_CUTOFF * 0.8f;
        scale = rad / minlight;
 
        VectorMA(transformed, -dist, surf->plane->normal, impact);
 
        local[0] = DotProduct(impact, tex->axis[0]) + tex->offset[0];
        local[1] = DotProduct(impact, tex->axis[1]) + tex->offset[1];
 
        local[0] -= surf->texturemins[0];
        local[1] -= surf->texturemins[1];
 
        block = blocklights;
        for (t = 0; t < tmax; t++) {
            td = abs(local[1] - (t << 4));
            for (s = 0; s < smax; s++) {
                sd = abs(local[0] - (s << 4));
                if (sd > td)
                    dist = sd + (td >> 1);
                else
                    dist = td + (sd >> 1);
                if (dist < minlight) {
                    frac = (rad - dist * scale) * sw_modulate->value * 256;
                    block[0] += light->color[0] * frac;
                    block[1] += light->color[1] * frac;
                    block[2] += light->color[2] * frac;
                }
                block += LIGHTMAP_BYTES;
            }
        }
    }
}

Referenced by R_BuildLightMap().

R_BuildLightMap()

void R_BuildLightMap

(

void

)

Definition at line 290 of file light.c.

{
    int             i, maps, smax, tmax, size;
    byte            *lightmap;
    mface_t         *surf;
    blocklight_t    *block;
 
    surf = r_drawsurf.surf;
    smax = S_MAX(surf);
    tmax = T_MAX(surf);
    size = smax * tmax;
 
    if (size > MAX_BLOCKLIGHTS)
        Com_Error(ERR_DROP, "R_BuildLightMap: surface blocklights size %i > %i", size, MAX_BLOCKLIGHTS);
 
    if (r_fullbright->integer || !surf->lightmap) {
        block = blocklights;
        for (i = 0; i < size; i++) {
            block[0] = block[1] = block[2] = 0xffff;
            block += LIGHTMAP_BYTES;
        }
        return;
    }
 
// clear to no light
    memset(blocklights, 0, sizeof(blocklights[0]) * size * LIGHTMAP_BYTES);
 
// add all the lightmaps
    lightmap = surf->lightmap;
    for (maps = 0; maps < surf->numstyles; maps++) {
        fixed8_t        scale;
 
        block = blocklights;
        scale = r_drawsurf.lightadj[maps];  // 8.8 fraction
        for (i = 0; i < size; i++) {
            block[0] += lightmap[0] * scale;
            block[1] += lightmap[1] * scale;
            block[2] += lightmap[2] * scale;
 
            lightmap += LIGHTMAP_BYTES;
            block += LIGHTMAP_BYTES;
        }
    }
 
// add all the dynamic lights
    if (surf->dlightframe == r_framecount)
        R_AddDynamicLights();
 
// bound
    block = blocklights;
    for (i = 0; i < size; i++) {
        blocklight_t    r, g, b, max;
 
        r = block[0];
        g = block[1];
        b = block[2];
 
        // catch negative lights
        if (r < 255)
            r = 255;
        if (g < 255)
            g = 255;
        if (b < 255)
            b = 255;
 
        // determine the brightest of the three color components
        max = g;
        if (r > max)
            max = r;
        if (b > max)
            max = b;
 
        // rescale all the color components if the intensity of the greatest
        // channel exceeds 1.0
        if (max > 65535) {
            float   y;
 
            y = 65535.0f / max;
            r *= y;
            g *= y;
            b *= y;
        }
 
        block[0] = r;
        block[1] = g;
        block[2] = b;
 
        block += LIGHTMAP_BYTES;
    }
}

Referenced by D_CacheSurface().

R_LightPoint()

void R_LightPoint	(	vec3_t	point,
		vec3_t	color
	)

Definition at line 174 of file light.c.

{
    int         lnum;
    dlight_t    *dl;
    float       add;
 
    if (!r_worldmodel || !r_worldmodel->lightmap || r_fullbright->integer) {
        VectorSet(color, 1, 1, 1);
        return;
    }
 
    VectorClear(color);
 
    if (!_R_LightPoint(point, color))
        VectorSet(color, 1, 1, 1);
 
    //
    // add dynamic lights
    //
    for (lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) {
        dl = &r_newrefdef.dlights[lnum];
        add = dl->intensity - DLIGHT_CUTOFF - Distance(point, dl->origin);
        if (add > 0) {
            add *= (1.0f / 255);
            VectorMA(color, add, dl->color, color);
        }
    }
 
    VectorScale(color, sw_modulate->value, color);
}

R_MarkLights()

void R_MarkLights

(

mnode_t *

headnode

)

Definition at line 76 of file light.c.

{
    dlight_t    *light;
    vec3_t      transformed;
    int         i;
 
    r_dlightframecount = r_framecount;
    for (i = 0, light = r_newrefdef.dlights; i < r_newrefdef.num_dlights; i++, light++) {
        if (insubmodel) {
            vec3_t      temp;
 
            VectorSubtract(light->origin, currententity->origin, temp);
            transformed[0] = DotProduct(temp, entity_rotation[0]);
            transformed[1] = DotProduct(temp, entity_rotation[1]);
            transformed[2] = DotProduct(temp, entity_rotation[2]);
        } else {
            VectorCopy(light->origin, transformed);
        }
        R_MarkLights_r(headnode, light, transformed, 1 << i);
    }
}

Referenced by R_DrawBEntitiesOnList(), and R_RenderFrame().

R_MarkLights_r()

static void R_MarkLights_r ( mnode_t *  node, dlight_t *  light, vec3_t  transformed, int  bit  )

static

Definition at line 38 of file light.c.

{
    float       dist;
    mface_t     *surf;
    int         i;
 
    while (node->plane) {
        dist = PlaneDiffFast(transformed, node->plane);
        if (dist > light->intensity - DLIGHT_CUTOFF) {
            node = node->children[0];
            continue;
        }
        if (dist < -light->intensity + DLIGHT_CUTOFF) {
            node = node->children[1];
            continue;
        }
 
        // mark the polygons
        surf = node->firstface;
        for (i = 0; i < node->numfaces; i++, surf++) {
            if (surf->dlightframe != r_dlightframecount) {
                surf->dlightbits = 0;
                surf->dlightframe = r_dlightframecount;
            }
            surf->dlightbits |= bit;
        }
 
        R_MarkLights_r(node->children[0], light, transformed, bit);
        node = node->children[1];
    }
}

Referenced by R_MarkLights().

Variable Documentation

blocklights

blocklight_t blocklights[MAX_BLOCKLIGHTS *LIGHTMAP_BYTES]

Definition at line 207 of file light.c.

Referenced by R_AddDynamicLights(), and R_BuildLightMap().

r_dlightframecount

int r_dlightframecount

Definition at line 22 of file light.c.

Referenced by R_DrawBEntitiesOnList(), R_MarkLights(), and R_MarkLights_r().