#include <assert.h>
#include <cstring>
#include "gl_globals.h"
#include "hashtable_3d.h"
#include "gl_light.h"
#include <math.h>
#include "gfx/matrix.h"

Macros
#define	M_PI 3.14159265358979323846264338328

#define	GFX_HARDWARE_LIGHTING

Functions
void	GFXUploadLightState (int max_light_location, int active_light_array, int apparent_light_size_array, bool shader, vector< int >::const_iterator begin, vector< int >::const_iterator end)

int	findLocalClobberable ()
	Finds the local lights that are clobberable for new lights (permanent perhaps) More...

static int	findGlobalClobberable ()

void	light_rekey_frame ()
	Rekeys a frame, remembering trashing old lights activated last frame. More...

Variables
const float	atten0scale = 1

const float	atten1scale = 1./GFX_SCALE

const float	atten2scale = 1./(GFX_SCALE*GFX_SCALE)

int	_GLLightsEnabled = 0
	How many lights are enabled (for fast picking) More...

Hashtable3d< LineCollideStar, 20, CTACC, lighthuge >	lighttable
	table to store local lights, numerical pointers to _llights (eg indices) More...

Macro Definition Documentation

#define GFX_HARDWARE_LIGHTING

Definition at line 139 of file gl_light_state.cpp.

#define M_PI 3.14159265358979323846264338328

Definition at line 11 of file gl_light_state.cpp.

Referenced by GFXUploadLightState().

Function Documentation

static int findGlobalClobberable ( )

static

Definition at line 173 of file gl_light_state.cpp.

References GFX_MAX_LIGHTS, OpenGLL::GLL_LOCAL, OpenGLL::GLL_ON, GLLights, i, and index.

Referenced by gfx_light::Create(), and gfx_light::Enable().

 {
     //searches through the GLlights and sees which one is clobberable.  Returns -1 if not.
     int clobberdisabled = -1;
     int clobberlocal    = -1;
     for (int i = 0; i < GFX_MAX_LIGHTS; i++) {
         if (GLLights[i].index == -1)
             return i;
         if (GLLights[i].options&OpenGLL::GLL_LOCAL)
             clobberlocal = i;
         if ( !(GLLights[i].options&OpenGLL::GLL_ON) )
             if (clobberlocal == i || clobberdisabled == -1)
                 clobberdisabled = i;
     }
     return (clobberdisabled == -1) ? clobberlocal : clobberdisabled;
 }

int findLocalClobberable ( )

Finds the local lights that are clobberable for new lights (permanent perhaps)

Definition at line 161 of file gl_light_state.cpp.

References GFX_MAX_LIGHTS, OpenGLL::GLL_ON, GLLights, i, and index.

Referenced by gfx_light::Create(), and gfx_light::dopickenables().

 {
     int clobberdisabled = -1;
     for (int i = 0; i < GFX_MAX_LIGHTS; i++) {
         if (GLLights[i].index == -1)
             return i;
         if ( !(GLLights[i].options&OpenGLL::GLL_ON) )
             clobberdisabled = i;
     }
     return clobberdisabled;
 }

void GFXUploadLightState	(	int	max_light_location,
		int	active_light_array,
		int	apparent_light_size_array,
		bool	shader,
		vector< int >::const_iterator	begin,
		vector< int >::const_iterator	end
	)

Definition at line 14 of file gl_light_state.cpp.

References gfx_light::ContextSwitchClobberLight(), gfx_light::enabled(), float, GFXLight::getPosition(), GFXLight::getSize(), GFX_MAX_LIGHTS, GFXGetMatrixModel(), GFXLoadIdentity(), GFXLoadMatrixModel(), GFXShaderConstant4v(), GFXShaderConstanti(), GFXShaderConstantv(), i, M_PI, MODEL, Matrix::p, QVector, and UniverseUtil::sqrt().

 {
     // FIXME: (klauss) Very bad thing: static variables initialized with heap-allocated arrays...
     static GLint *lightData = new GLint[GFX_MAX_LIGHTS];
     static float *lightSizes = new float[GFX_MAX_LIGHTS*4];
     
     Matrix modelview;
     
     // if we're using shaders, we'll need the modelview matrix
     // to properly compute light-model apparent light sizes
     GFXGetMatrixModel(modelview);
     
     size_t maxval = 0;
     size_t i = 0;
     
     for (vector<int>::const_iterator lightit = begin; lightit != end; ++i, ++lightit) {
         const gfx_light &light = (*_llights)[*lightit];
         if (light.enabled()) {
             lightData[i] = 1;
             maxval = i;
             
             // Only bother with apparent light size if there is a shader
             if (shader) {
                 // We'll compute apparent light size by transforming the origin
                 // position by the modelview matrix, and computing the apparent
                 // size of a lightsource to that center and the proper size
                 // as entered in _gllights.
                 //
                 // This assumes the modelview matrix will be already set to
                 // the proper value when the light is enabled. It should.
                 //
                 // NOTE: We explicitly ignore rotation and scaling parts of the
                 // matrix. For one, rotation is meaningless for this calculation.
                 // For two, scaling would be nullified when scaling both distance
                 // and light size, so it would only waste time.
                 
                 QVector lightPos = light.getPosition() - modelview.p;
                 
                 double lightDistance = lightPos.Magnitude();
                 double lightSize = light.getSize() * 0.5;
                 double lightCosAngle;
                 double lightSolidAngle;
                 if (lightSize <= 0.0) {
                     // Point light always has zero solid angle
                     lightCosAngle = 1.0;
                     lightSolidAngle = 0.0;
                 } else {
                     // NOTE: assuming lightSize > 0, the following condition
                     //  assures a nonzero distance to light, which would produce
                     //  NaNs in the following math.
                     if (lightDistance > lightSize) {
                         // Light cos angle is:
                         //  Vector(1, 0, 0) . Vector(lightDistance, lightSize, 0).Normalize()
                         // Which happens to resolve to:
                         //lightCosAngle = float(lightDistance / (lightDistance + lightSize));
                         lightCosAngle = lightDistance / sqrt( lightDistance*lightDistance + lightSize*lightSize );
                         lightSolidAngle = 2.0 * M_PI * ( 1.0 - lightCosAngle );
                         // Light steradians is:
                         //  Steradians = Fractional Area * 4 * Pi
                         //  Fractional Area = Apparent light area / Sky area at light distance
                         //  Apparent light area = Pi * lightSize^2
                         //  Sky area = 4 * Pi * lightDistance^2
                         // Do the math...
                         /*lightSolidAngle = float(M_PI
                             * ( lightSize / lightDistance )
                             * ( lightSize / lightDistance ));*/
                     } else {
                         // nil distance, avoid infinites that kill shaders
                         // NOTE: the constants aren't capricious, they're the right
                         //  constants for a light coming from all around.
                         lightCosAngle = 0.0;
                         lightSolidAngle = 2.0 * M_PI;
                     }
                 }
                 lightSizes[i*4+0] = float(lightSize);
                 lightSizes[i*4+1] = float(lightCosAngle);
                 lightSizes[i*4+2] = float(lightSolidAngle);
                 lightSizes[i*4+3] = 0.f;
             }
         }
         else {
             lightData[i] = 0;
             lightSizes[i*4+0] = 0.f;
             lightSizes[i*4+1] = 0.f;
             lightSizes[i*4+2] = 0.f;
             lightSizes[i*4+3] = 0.f;
         }
     }
     
     for (; i < (size_t)GFX_MAX_LIGHTS; ++i) {
         lightData[i] = 0;
         lightSizes[i*4+0] = 0.f;
         lightSizes[i*4+1] = 0.f;
         lightSizes[i*4+2] = 0.f;
         lightSizes[i*4+3] = 0.f;
     }
     
     if (!shader) {
         //only bother with actual GL state in the event of lack of shaders
         for (size_t i = 0; i < (size_t) GFX_MAX_LIGHTS; ++i) {
             int isenabled = glIsEnabled( GL_LIGHT0+i );
             if (isenabled && !lightData[i])
                 glDisable( GL_LIGHT0+i );
             else if (lightData[i] && !isenabled)
                 glEnable( GL_LIGHT0+i );
         }
     } else {
         //only bother with shader constants it there is a shader
         GFXLoadIdentity( MODEL );
         for (size_t i = 0; i <= maxval; ++i) {
             if (lightData[i]) {
                 const gfx_light &light = (*_llights)[*(begin+i)];
                 light.ContextSwitchClobberLight(GL_LIGHT0+i, -1);
             }
         }
         GFXLoadMatrixModel( modelview );
         if (active_light_array >= 0)
             GFXShaderConstantv( active_light_array, GFX_MAX_LIGHTS, (int*) lightData );
         if (max_light_location >= 0)
             GFXShaderConstanti( max_light_location, maxval );
         if (apparent_light_size_array >= 0)
             GFXShaderConstant4v( apparent_light_size_array, GFX_MAX_LIGHTS, (float*)lightSizes );
     }
 }

void light_rekey_frame ( )

Rekeys a frame, remembering trashing old lights activated last frame.

Definition at line 498 of file gl_light_state.cpp.

References _llights, GFX_MAX_LIGHTS, OpenGLL::GL_ENABLED, GLLights, i, OpenGLLights::index, index, OpenGLLights::options, and unpicklights().

Referenced by GFXBeginScene().

 {
     unpicklights();     //picks doubtless changed position
     for (int i = 0; i < GFX_MAX_LIGHTS; i++) {
         if (GLLights[i].options&OpenGLL::GL_ENABLED) {
             if (GLLights[i].index >= 0) {
                 if ( (*_llights)[GLLights[i].index].Target() == i ) {
                     (*_llights)[GLLights[i].index].SendGLPosition( GL_LIGHT0+i );                       //send position transformed by current cam matrix
                 } else {
                     unsigned int li = GLLights[i].index;
                     if ( (*_llights)[li].enabled() && ( (*_llights)[li].Target() == -1 ) ) {
                         (*_llights)[li].ClobberGLLight( i );
                     } else {
                         glDisable( GL_LIGHT0+i );
                         GLLights[i].index = -1;
                     }
                 }
             } else {
                 glDisable( GL_LIGHT0+i );
                 GLLights[i].options &= (~OpenGLL::GL_ENABLED);
             }
         }
     }
 }