r_light.cpp

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 "r_local.h"
#include "r_light.h"
#include "r_entity.h"
#include "r_state.h"
 
static sustain_t r_sustainArray[MAX_GL_LIGHTS];

void R_AddLight (const vec3_t origin, float radius, const vec3_t color)
{
    int i;
 
    if (refdef.numDynamicLights == MAX_GL_LIGHTS)
        return;
 
    i = refdef.numDynamicLights++;
 
    VectorCopy(origin, refdef.dynamicLights[i].origin);
    refdef.dynamicLights[i].radius = radius;
    VectorCopy(color, refdef.dynamicLights[i].color);
 
    Com_DPrintf(DEBUG_RENDERER, "added dynamic light, color (%f, %f, %f) position (%f, %f, %f)  radius=%f\n",
        color[0], color[1], color[2],
        origin[0], origin[1], origin[2],
        radius);
}

void R_AddSustainedLight (const vec3_t org, float radius, const vec3_t color, float sustain)
{
    sustain_t* s = r_sustainArray;
 
    int i;
    for (i = 0; i < MAX_GL_LIGHTS; i++, s++)
        if (!s->sustain)
            break;
 
    if (i == MAX_GL_LIGHTS)
        return;
 
    VectorCopy(org, s->light.origin);
    s->light.radius = radius;
    VectorCopy(color, s->light.color);
 
    s->time = refdef.time;
    s->sustain = refdef.time + sustain;
}

void R_UpdateSustainedLights (void)
{
    sustain_t* s;
    int i;
 
    /* sustains must be recalculated every frame */
    for (i = 0, s = r_sustainArray; i < MAX_GL_LIGHTS; i++, s++) {
        float intensity;
        vec3_t color;
 
        if (s->sustain <= refdef.time) {  /* clear it */
            s->sustain = 0;
            continue;
        }
 
        intensity = (s->sustain - refdef.time) / (s->sustain - s->time);
        VectorScale(s->light.color, intensity, color);
 
        R_AddLight(s->light.origin, s->light.radius, color);
    }
}

void R_EnableWorldLights (void)
{
    int i;
    int maxLights = r_dynamic_lights->integer;
    vec3_t lightPositions[MAX_GL_LIGHTS];
    vec4_t lightParams[MAX_GL_LIGHTS];
 
    /* with the current blending model, lighting breaks FFP world render */
    if (!r_programs->integer) {
        return;
    }
 
    if (!r_dynamic_lights->integer)
        return;
 
    for (i = 0; i < refdef.numDynamicLights && i < maxLights; i++) {
        const light_t* light = &refdef.dynamicLights[i];
 
        GLPositionTransform(r_locals.world_matrix, light->origin, lightPositions[i]);
        VectorCopy(light->color, lightParams[i]);
        lightParams[i][3] = 16.0 / (light->radius * light->radius);
    }
 
    /* if there aren't enough active lights, turn off the rest */
    for (;i < maxLights ;i++)
        Vector4Set(lightParams[i], 0, 0, 0, 1);
 
    /* Send light data to shaders */
    R_ProgramParameter3fvs("LIGHTPOSITIONS", maxLights, (GLfloat*)lightPositions);
    R_ProgramParameter4fvs("LIGHTPARAMS", maxLights, (GLfloat*)lightParams);
 
    R_EnableAttribute("TANGENTS");
}

void R_EnableModelLights (const light_t** lights, int numLights, bool inShadow, bool enable)
{
    int i;
    int maxLights = r_dynamic_lights->integer;
    vec4_t blackColor = {0.0, 0.0, 0.0, 1.0};
    const vec4_t whiteColor = {1.0, 1.0, 1.0, 1.0};
    const vec4_t defaultLight0Position = {0.0, 0.0, 1.0, 0.0};
    vec3_t lightPositions[MAX_GL_LIGHTS];
    vec4_t lightParams[MAX_GL_LIGHTS];
 
    if (r_programs->integer == 0) { /* Fixed function path renderer got only the sunlight */
        /* Setup OpenGL light #0 to act as a sun and environment light */
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_COLOR_MATERIAL);
#ifndef GL_VERSION_ES_CM_1_0
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
#endif
 
        glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0);
        glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0);
        glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0);
 
        glLightfv(GL_LIGHT0, GL_SPECULAR, blackColor);
        glLightfv(GL_LIGHT0, GL_AMBIENT, refdef.modelAmbientColor);
 
        glLightfv(GL_LIGHT0, GL_POSITION, refdef.sunVector);
 
        if (enable) {
            if (inShadow) {
                /* ambient only */
                glLightfv(GL_LIGHT0, GL_DIFFUSE, blackColor);
            } else {
                /* Full sunlight */
                glLightfv(GL_LIGHT0, GL_DIFFUSE, refdef.sunDiffuseColor);
            }
        } else {
            /* restore the default OpenGL state */
            glDisable(GL_LIGHTING);
            glDisable(GL_COLOR_MATERIAL);
 
            glLightfv(GL_LIGHT0, GL_POSITION, defaultLight0Position);
            glLightfv(GL_LIGHT0, GL_AMBIENT, blackColor);
            glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteColor);
            glLightfv(GL_LIGHT0, GL_SPECULAR, whiteColor);
        }
        return;
    }
 
    assert(numLights <= MAX_GL_LIGHTS);
 
    if (!enable || !r_state.lighting_enabled) {
        if (r_state.dynamic_lighting_enabled) {
            R_DisableAttribute("TANGENTS"); 
 
            if (maxLights) {
                for (i = 0; i < maxLights; i++)
                    Vector4Set(lightParams[i], 0, 0, 0, 1);
 
                /* Send light data to shaders */
                R_ProgramParameter3fvs("LIGHTPOSITIONS", maxLights, (GLfloat*)lightPositions);
                R_ProgramParameter4fvs("LIGHTPARAMS", maxLights, (GLfloat*)lightParams);
            }
        }
 
        r_state.dynamic_lighting_enabled = false;
        return;
    }

    if (numLights > maxLights)
        numLights = maxLights;
 
    r_state.dynamic_lighting_enabled = true;
 
    R_EnableAttribute("TANGENTS");
 
    R_UseMaterial(&defaultMaterial);
 
    R_ProgramParameter3fv("AMBIENT", refdef.modelAmbientColor);
 
    if (inShadow) {
        R_ProgramParameter3fv("SUNCOLOR", blackColor);
    } else {
        R_ProgramParameter3fv("SUNCOLOR", refdef.sunDiffuseColor);
    }
 
    if (!maxLights)
        return;
 
    for (i = 0; i < numLights; i++) {
        const light_t* light = lights[i];
 
        GLPositionTransform(r_locals.world_matrix, light->origin, lightPositions[i]);
        VectorCopy(light->color, lightParams[i]);
        lightParams[i][3] = 16.0 / (light->radius * light->radius);
    }
 
    /* if there aren't enough active lights, turn off the rest */
    for (; i < maxLights; i++)
        Vector4Set(lightParams[i], 0, 0, 0, 1);
 
    /* Send light data to shaders */
    R_ProgramParameter3fvs("LIGHTPOSITIONS", maxLights, (GLfloat*)lightPositions);
    R_ProgramParameter4fvs("LIGHTPARAMS", maxLights, (GLfloat*)lightParams);
}

void R_AddStaticLight (const vec3_t origin, float radius, const vec3_t color)
{
    if (refdef.numStaticLights >= MAX_STATIC_LIGHTS) {
        Com_Printf("Failed to add lightsource: MAX_STATIC_LIGHTS exceeded\n");
        return;
    }
 
    Com_DPrintf(DEBUG_RENDERER, "added static light, color (%f, %f, %f) position (%f, %f, %f)  radius=%f\n",
        color[0], color[1], color[2],
        origin[0], origin[1], origin[2],
        radius);
 
    light_t* light = &refdef.staticLights[refdef.numStaticLights++];
 
    VectorCopy(origin, light->origin);
    VectorCopy(color, light->color);
    light->color[3] = 1.0; /* needed if we pass this light as parameter to glLightxxx() */
    light->radius = radius;
}
 
/* If glow was enabled, disable it before calling this function, or rendering state will become incoherent */
void R_DisableLights (void)
{
    vec4_t blackColor = {0.0, 0.0, 0.0, 1.0};
 
    for (int i = 0; i < MAX_GL_LIGHTS; i++) {
        glLightf(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, MIN_GL_CONSTANT_ATTENUATION);
        glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, blackColor);
        glLightfv(GL_LIGHT0 + i, GL_AMBIENT, blackColor);
        glLightfv(GL_LIGHT0 + i, GL_SPECULAR, blackColor);
        glDisable(GL_LIGHT0 + i);
    }
    glDisable(GL_LIGHTING);
}

void R_ClearStaticLights (void)
{
    refdef.numStaticLights = 0;
}

static void R_AddLightToEntity (const vec_t* pos, lighting_t* ltng, const light_t* light, const float distSqr)
{
    int i;
    int maxLights = r_dynamic_lights->integer;
    const light_t** el = ltng->lights;
 
    for (i = 0; i < ltng->numLights; i++) {
        if (i == maxLights)
            return;
        if (distSqr < VectorDistSqr((el[i]->origin), pos)) { 
            /* found more distant light, push it down the list and insert this one*/
            if (i + 1 == maxLights) {
                /* shortcut in case light we are replacing is the last light possible; also acts as the overflow guard */
                el[i] = light;
                return;
            }
 
            while (i < ltng->numLights) {
                const light_t* tmp = el[i];
                el[i++] = light;
                light = tmp;
            }
 
            break;
        }
    }
 
    if (i == maxLights)
        return;
 
    el[i++] = light;
    ltng->numLights = i;
}
 
static lighting_t fakeLightingData; 

void R_UpdateLightList (entity_t* ent)
{
    int i;
    vec_t* pos;             
    entity_t* rootEnt;      
    lighting_t* ltng;       
    vec3_t diametralVec;    
    float diameter;         
    bool cached = false;
 
    /* Find the root of tagent tree which actually owns the lighting data; it is assumed that there is no loops,
     * since R_CalcTransform calls Com_Error on those */
    for (rootEnt = ent; rootEnt->tagent; rootEnt = ent->tagent)
        ;
 
    ltng = ent->lighting = rootEnt->lighting;
 
    if (!ltng) {
        /* Entity got no lighting data, so substitute defaults (no dynamic lights, but exposed to sunlight) */
        OBJZERO(fakeLightingData);
        ent->lighting = &fakeLightingData;
        return;
    }
 
    if (ltng->lastLitFrame == r_locals.frame)
        return; /* nothing to do, already calculated lighting for this frame */
 
    ltng->lastLitFrame = r_locals.frame;
 
    /* we have to use the offset from (accumulated) transform matrix, because entity origin is not necessarily the point where model is acually rendered */
    pos = ent->transform.matrix + 12; /* type system hack, sorry */
 
    ent->eBox.getDiagonal(diametralVec); 
    diameter = VectorLength(diametralVec);

    if (VectorDist(pos, ltng->lastCachePos) < CACHE_CLEAR_TRESHOLD) {
        cached = true;
    } else {
        ltng->numLights = 0; /* clear the list of lights */
        ltng->numCachedLights = 0;
        VectorCopy(pos, ltng->lastCachePos);
    }
 
    /* Check if origin of this entity is hit by sunlight (not the best test, but at least fast) */
    if (!cached) {
        if (ent->flags & RF_ACTOR) { 
            vec3_t fakeSunPos; 
            VectorMA(pos, 8192.0, refdef.sunVector, fakeSunPos);
            R_Trace(Line(pos, fakeSunPos), 0, MASK_SOLID);
            ltng->inShadow = refdef.trace.fraction != 1.0;
        } else {
            ltng->inShadow = false;
        }
    }
 
    if (!r_dynamic_lights->integer)
        return;
 
    if (!cached) {
        /* Rebuild list of static lights */
        for (i = 0; i < refdef.numStaticLights; i++) {
            light_t* light = &refdef.staticLights[i];
            const float distSqr = VectorDistSqr(pos, light->origin);
 
            if (distSqr > (diameter + light->radius) * (diameter + light->radius))
                continue;
 
            R_Trace(Line(pos, light->origin), 0, MASK_SOLID);
 
            if (refdef.trace.fraction == 1.0)
                R_AddLightToEntity(pos, ltng, light, distSqr);
        }
        /* Save static lights to cache */
        for (i = 0; i < ltng->numLights; i++)
            ltng->cachedLights[i] = ltng->lights[i];
        ltng->numCachedLights = ltng->numLights;
    } else {
        /* Copy static lights from cache */
        for (i = 0; i < ltng->numCachedLights; i++)
            ltng->lights[i] = ltng->cachedLights[i];
        ltng->numLights = ltng->numCachedLights;
    }
 
    /* add dynamic lights, too */
    for (i = 0; i < refdef.numDynamicLights; i++) {
        light_t* light = &refdef.dynamicLights[i];
        const float distSqr = VectorDistSqr(pos, light->origin);
 
        if (distSqr > (diameter + light->radius) * (diameter + light->radius))
            continue;
 
        R_Trace(Line(pos, light->origin), 0, MASK_SOLID);
 
        if (refdef.trace.fraction == 1.0)
            R_AddLightToEntity(pos, ltng, light, distSqr);
    }
}