gfx_light Class Reference

#include <gl_light.h>

Inheritance diagram for gfx_light:

Public Member Functions
	gfx_light ()
GFXLight	operator= (const GFXLight &tmp)
	assigns a GFXLight to a gfx_light More...
int	lightNum ()
	Returns the number this light is in the _llights list. More...
bool	LocalLight () const
	Returns if this light was saved as a local light. More...
bool	enabled () const
	Retursn if this light is enabled. More...
int &	Target ()
	Returns the target OpenGL light of this light. -1 is unassigned to a "real" light. More...
bool	Create (const GFXLight &, bool global)
void	Kill ()
	Disables it (may remove from table), trashes it from GLlights. sets target to -2 (dead) More...
void	SendGLPosition (const GLenum target) const
	properly utilizes union to send to OGL More...
void	ClobberGLLight (const int target)
	replaces target GL light in the implementation. Sets this->target! Checks for -1 and calls ContextSwitch to clobber completely More...
void	FinesseClobberLight (const GLenum target, const int original)
	replaces target GL light, copying all state sets this->target! More...
void	ContextSwitchClobberLight (const GLenum target, const int original) const
	replaces target GL light, copying all state sets this->target! More...
void	Enable ()
void	Disable ()
void	ResetProperties (const enum LIGHT_TARGET, const GFXColor &color)
void	AddToTable ()
	Adds this light to table (assume local) More...
bool	RemoveFromTable (bool shouldremove=true, const GFXLight &t=GFXLight())
	Removes this light from light table. More...
void	TrashFromGLLights ()
	Trash this light from active GLLights. More...
LineCollide	CalculateBounds (bool &err)
	calculates bounds for the table given cutoffs! More...
Public Member Functions inherited from GFXLight
	GFXLight ()
	GFXLight (const bool enabled, const GFXColor &vect, const GFXColor &diffuse=GFXColor(0, 0, 0, 1), const GFXColor &specular=GFXColor(0, 0, 0, 1), const GFXColor &ambient=GFXColor(0, 0, 0, 1), const GFXColor &attenuate=GFXColor(1, 0, 0), const GFXColor &direction=GFXColor(0, 0, 0), float exp=0.0f, float cutoff=180.0f, float size=0.0f)
void	SetProperties (enum LIGHT_TARGET, const GFXColor &color)
GFXColor	GetProperties (enum LIGHT_TARGET) const
void	setSize (float size_)
float	getSize () const
Vector	getPosition () const
void	disable ()
void	enable ()
bool	attenuated () const
void	apply_attenuate (bool attenuated)

Static Public Member Functions
static void	dopickenables ()
	Do all enables from picking. More...

Additional Inherited Members
Public Attributes inherited from GFXLight
int	target
	physical GL light its saved in More...
float	vect [3]
	last is w for positional, otherwise 3 for spec More...
int	options
float	diffuse [4]
float	specular [4]
float	ambient [4]
float	attenuate [3]
float	direction [3]
float	exp
float	cutoff
float	size

Detailed Description

This stores the state of a given GL Light in its fullness It inherits all values a light may have, and gains a number of functions that assist it in maintaining the virtual OpenGL state amidst the limited Number of lights, etc

Definition at line 23 of file gl_light.h.

Constructor & Destructor Documentation

gfx_light::gfx_light ( )

inline

Definition at line 25 of file gl_light.h.

: gfx_light() : GFXLight() {}

Member Function Documentation

void gfx_light::AddToTable

(

)

Adds this light to table (assume local)

Definition at line 388 of file gl_light_state.cpp.

References CalculateBounds(), LineCollideStar::lc, and Hashtable3d< T, COLLIDETABLESIZE, COLLIDETABLEACCURACY, HUGEOBJECT >::Put().

Referenced by Enable(), and ResetProperties().

{
    LineCollideStar tmp;
    bool err;
    LineCollide    *coltarg = new LineCollide( CalculateBounds( err ) );     //leak??
    if (err)
        return;
    tmp.lc = coltarg;
    lighttable.Put( coltarg, tmp );
}

LineCollide gfx_light::CalculateBounds

(

bool &

err)

calculates bounds for the table given cutoffs!

Definition at line 472 of file gl_light_state.cpp.

References GFXLight::ambient, GFXLight::attenuate, GFXLight::diffuse, intensity_cutoff, lightNum(), LineCollide::object, QVector, GFXLight::specular, UniverseUtil::sqrt(), LineCollide::UNIT, and GFXLight::vect.

Referenced by AddToTable(), and RemoveFromTable().

{
    error = false;
    float tot_intensity = ( (specular[0]+specular[1]+specular[2])*specular[3]
                           +(diffuse[0]+diffuse[1]+diffuse[2])*diffuse[3]
                           +(ambient[0]+ambient[1]+ambient[2])*ambient[3] )*.33;
    //double d = (-(double)attenuate[1]+sqrt((double)attenuate[1]*(double)attenuate[1]+4*(double)attenuate[2]*(((double)tot_intensity/(double)intensity_cutoff) - (double)attenuate[0])))/(2*(double)attenuate[2]);
    //simplistic calculation above causes floating point inaccuracies
    double ffastmathreallysucksd;
    double ffastmathreallysucksq;

    ffastmathreallysucksd = sqrt( tot_intensity/intensity_cutoff-ambient[0] );

    ffastmathreallysucksq = sqrt( attenuate[2]+attenuate[1] );
    //VSFileSystem::Fprintf (stderr,"q%lf d%lf",ffastmathreallysucksq,ffastmathreallysucksd);
    if (ffastmathreallysucksq == 0 || ffastmathreallysucksd <= 0)
        error = true;
    ffastmathreallysucksd /= ffastmathreallysucksq;

    QVector     st( vect[0]-ffastmathreallysucksd, vect[1]-ffastmathreallysucksd, vect[2]-ffastmathreallysucksd );
    QVector     end( vect[0]+ffastmathreallysucksd, vect[1]+ffastmathreallysucksd, vect[2]+ffastmathreallysucksd );
    LineCollide retval( NULL, LineCollide::UNIT, st, end );
    *( (int*) (&retval.object) ) = lightNum();       //put in a lightNum
    return retval;
}

void gfx_light::ClobberGLLight

(

const int

target)

replaces target GL light in the implementation. Sets this->target! Checks for -1 and calls ContextSwitch to clobber completely

Definition at line 280 of file gl_light_state.cpp.

References ContextSwitchClobberLight(), enabled(), FinesseClobberLight(), OpenGLL::GL_ENABLED, OpenGLL::GLL_LOCAL, OpenGLL::GLL_ON, GLLights, OpenGLLights::index, index, lightNum(), LocalLight(), OpenGLLights::options, GFXLight::options, and GFXLight::target.

Referenced by Create(), and Enable().

{
    this->target = target;
    if ( enabled() != ( (GLLights[target].options&OpenGLL::GL_ENABLED) != 0 ) ) {
        if ( enabled() ) {
            glEnable( GL_LIGHT0+target );
            GLLights[target].options |= OpenGLL::GL_ENABLED;
        } else {
            GLLights[target].options &= (~OpenGLL::GL_ENABLED);
            glDisable( GL_LIGHT0+target );
        }
    }
    GLLights[target].options &= (OpenGLL::GL_ENABLED);     //turn off options
#ifdef GFX_HARDWARE_LIGHTING
    if (GLLights[target].index == -1) {
#endif
    ContextSwitchClobberLight( GL_LIGHT0+target, GLLights[target].index );
#ifdef GFX_HARDWARE_LIGHTING
    } else {
        FinesseClobberLight( GL_LIGHT0+target, GLLights[target].index );
    }
#endif
    this->target = target;
    //VSFileSystem::Fprintf (stderr,"Target %d had light %d",target, GLLights[target].index);
    GLLights[target].index    = lightNum();
    //VSFileSystem::Fprintf (stderr," Clobbered with %d\n",lightNum());
    GLLights[target].options |= OpenGLL::GLL_ON*enabled()+OpenGLL::GLL_LOCAL * LocalLight();
}

void gfx_light::ContextSwitchClobberLight ( const GLenum  target, const int  original  ) const

inline

replaces target GL light, copying all state sets this->target!

Definition at line 231 of file gl_light_state.cpp.

References GFXLight::ambient, atten0scale, atten1scale, atten2scale, GFXLight::attenuate, GFXLight::diffuse, GLLights, OpenGLLights::index, SendGLPosition(), GFXLight::specular, and GFXLight::target.

Referenced by ClobberGLLight(), and GFXUploadLightState().

{
    glLightf( gltarg, GL_CONSTANT_ATTENUATION, attenuate[0]*atten0scale );
    glLightf( gltarg, GL_LINEAR_ATTENUATION, attenuate[1]*atten1scale );
    glLightf( gltarg, GL_QUADRATIC_ATTENUATION, attenuate[2]*atten2scale );

    SendGLPosition( gltarg );
    glLightfv( gltarg, GL_DIFFUSE, diffuse );
    glLightfv( gltarg, GL_SPECULAR, specular );
    glLightfv( gltarg, GL_AMBIENT, ambient );
    if (original != -1) {
        gfx_light *orig = &( (*_llights)[GLLights[original].index] );
        orig->target = -1;
        GLLights[original].index = -1;
    }
}

bool gfx_light::Create	(	const GFXLight &	temp,
		bool	global
	)

if global, puts it into GLlights (if space ||enabled) <clobber?> for local lights, if enabled, call Enable().

Definition at line 190 of file gl_light_state.cpp.

References _GLLightsEnabled, ClobberGLLight(), GFXLight::disable(), Enable(), enabled(), findGlobalClobberable(), findLocalClobberable(), GFX_LOCAL_LIGHT, and GFXLight::options.

{
    int foundclobberable = 0;
    *this = temp;
    if (!global) {
        options |= GFX_LOCAL_LIGHT;
        if ( enabled() ) {
            disable();
            this->Enable();             //upon creation need to call enable script with disabled light
        }
    } else {
        options &= (~GFX_LOCAL_LIGHT);
        foundclobberable = enabled() ? findGlobalClobberable() : findLocalClobberable();
        if (foundclobberable != -1) {
            _GLLightsEnabled += (enabled() != 0);
            ClobberGLLight( foundclobberable );
        }
    }
    return (foundclobberable != -1) || ( !enabled() );
}

void gfx_light::Disable

(

)

for global lights, GLdisables it. for local lights, removes it from the table. and trashes it form GLlights.

Definition at line 449 of file gl_light_state.cpp.

References _GLLightsEnabled, GFXLight::disable(), enabled(), OpenGLL::GL_ENABLED, OpenGLL::GLL_ON, GLLights, LocalLight(), OpenGLLights::options, GFXLight::options, RemoveFromTable(), GFXLight::target, and TrashFromGLLights().

Referenced by Kill().

{
    if ( enabled() ) {
        disable();
        if (target >= 0) {
            if (GLLights[target].options&OpenGLL::GL_ENABLED) {
                _GLLightsEnabled--;
                glDisable( GL_LIGHT0+this->target );
            }
            GLLights[this->target].options &= ( ~(OpenGLL::GL_ENABLED|OpenGLL::GLL_ON) );
        }
        if ( LocalLight() && enabled() ) {
            RemoveFromTable();
            if (target >= 0)
                TrashFromGLLights();
        }
    }
}

void gfx_light::dopickenables ( )

static

Do all enables from picking.

Definition at line 187 of file gl_light_pick.cpp.

References _llights, findLocalClobberable(), OpenGLL::GL_ENABLED, OpenGLL::GLL_LOCAL, GLLights, OpenGLLights::index, newpicked, oldpicked, OpenGLLights::options, GFXLight::options, and VSFileSystem::vs_fprintf().

Referenced by GFXPickLights().

{
    //sort it to find minimum num lights changed from last time.
    sort( newpicked->begin(), newpicked->end() );
    //newpicked->sort();
    std::vector< int >::iterator traverse = newpicked->begin();
    std::vector< int >::iterator oldtrav;
    while ( traverse != newpicked->end() && ( !oldpicked->empty() ) ) {
        oldtrav = oldpicked->begin();
        while (oldtrav != oldpicked->end() && *oldtrav < *traverse)
            oldtrav++;
        if ( ( (*traverse) == (*oldtrav) ) && ( (*_llights)[*oldtrav].target >= 0 ) )
            //BOGUS ASSERT... just like this light wasn't on if it was somehow clobberedassert (GLLights[(*_llights)[oldpicked->front()].target].index == oldpicked->front());
            oldpicked->erase( oldtrav );              //already taken care of. main screen turn on ;-)
        traverse++;
    }
    oldtrav = oldpicked->begin();
    while ( oldtrav != oldpicked->end() ) {
        if ( GLLights[(*_llights)[(*oldtrav)].target].index != (*oldtrav) ) {
            oldtrav++;
            continue;             //don't clobber what's not yours
        }
        GLLights[(*_llights)[(*oldtrav)].target].index    = -1;
        GLLights[(*_llights)[(*oldtrav)].target].options &= (OpenGLL::GL_ENABLED&OpenGLL::GLL_LOCAL);               //set it to be desirable to kill
        oldtrav++;
    }
    traverse = newpicked->begin();
    while ( traverse != newpicked->end() ) {
        if (*traverse>=(int)_llights->size()) {
            VSFileSystem::vs_fprintf (stderr,"GFXLIGHT FAILURE %d is beyond array of size %d",(int)*traverse,(int)_llights->size());
            traverse++;
            continue;
        }
        if ( (*_llights)[*traverse].target == -1 ) {
            int gltarg = findLocalClobberable();
            if (gltarg == -1) {
                newpicked->erase( traverse, newpicked->end() );                 //erase everything on the picked list. Nothing can fit;
                break;
            }
            (*_llights)[(*traverse)].ClobberGLLight( gltarg );
        }
        traverse++;
    }
    /*while (!oldpicked->empty()) {
     *  int glind=(*_llights)[oldpicked->front()].target;
     *  if ((GLLights[glind].options&OpenGLL::GL_ENABLED)&&GLLights[glind].index==-1) {//if hasn't been duly clobbered
     *   glDisable (GL_LIGHT0+glind);
     *   GLLights[glind].options &= (~OpenGLL::GL_ENABLED);
     *  }
     *  (*_llights)[oldpicked->front()].target=-1;//make sure it doesn't think it owns any gl lights!
     *  oldpicked->pop_front();
     *  }*/
    for (oldtrav = oldpicked->begin(); oldtrav != oldpicked->end(); oldtrav++) {
        if (*oldtrav>=(int)_llights->size()) {
            VSFileSystem::vs_fprintf (stderr,"GFXLIGHT FAILURE %d is beyond array of size %d",(int)*oldtrav,(int)_llights->size());
            continue;
        }

        int glind = (*_llights)[*oldtrav].target;
        if ( (GLLights[glind].options&OpenGLL::GL_ENABLED) && GLLights[glind].index == -1 ) {
            //if hasn't been duly clobbered
            glDisable( GL_LIGHT0+glind );
            GLLights[glind].options &= (~OpenGLL::GL_ENABLED);
        }
        (*_llights)[*oldtrav].target = -1;           //make sure it doesn't think it owns any gl lights!
    }
    oldpicked->clear();
}

void gfx_light::Enable

(

)

for global lights, clobbers SOMETHING for sure, calls GLenable for local lights, puts it into the light table

Definition at line 428 of file gl_light_state.cpp.

References _GLLightsEnabled, AddToTable(), ClobberGLLight(), GFXLight::enable(), enabled(), findGlobalClobberable(), OpenGLL::GL_ENABLED, OpenGLL::GLL_ON, GLLights, LocalLight(), OpenGLLights::options, and GFXLight::target.

Referenced by Create().

{
    if ( !enabled() ) {
        if ( LocalLight() ) {
            AddToTable();
        } else {
            if (target == -1) {
                int newtarg = findGlobalClobberable();
                if (newtarg == -1)
                    return;
                _GLLightsEnabled++;
                ClobberGLLight( newtarg );
            }
            glEnable( GL_LIGHT0+this->target );
            GLLights[this->target].options |= OpenGLL::GL_ENABLED|OpenGLL::GLL_ON;
        }
        enable();
    }
}

bool gfx_light::enabled ( ) const

inline

Retursn if this light is enabled.

Definition at line 36 of file gl_light.h.

References GFX_LIGHT_ENABLED, and GFXLight::options.

Referenced by ClobberGLLight(), Create(), Disable(), Enable(), and GFXUploadLightState().

    {
        return (options&GFX_LIGHT_ENABLED) != 0;
    }

void gfx_light::FinesseClobberLight ( const GLenum  target, const int  original  )

inline

replaces target GL light, copying all state sets this->target!

Definition at line 248 of file gl_light_state.cpp.

References GFXLight::ambient, atten0scale, atten1scale, atten2scale, GFXLight::attenuate, GFXLight::attenuated(), GFXLight::diffuse, GLLights, OpenGLLights::index, SendGLPosition(), GFXLight::specular, GFXLight::target, and GFXLight::vect.

Referenced by ClobberGLLight().

{
    gfx_light *orig = &( (*_llights)[GLLights[original].index] );
    if ( attenuated() ) {
        if ( orig->attenuated() ) {
            if (orig->attenuate[0] != attenuate[0])
                glLightf( gltarg, GL_CONSTANT_ATTENUATION, attenuate[0]*atten0scale );
            if (orig->attenuate[1] != attenuate[1])
                glLightf( gltarg, GL_LINEAR_ATTENUATION, attenuate[1]*atten1scale );
            if (orig->attenuate[2] != attenuate[2])
                glLightf( gltarg, GL_QUADRATIC_ATTENUATION, attenuate[2]*atten2scale );
        } else {
            glLightf( gltarg, GL_CONSTANT_ATTENUATION, attenuate[0]*atten0scale );
            glLightf( gltarg, GL_LINEAR_ATTENUATION, attenuate[1]*atten1scale );
            glLightf( gltarg, GL_QUADRATIC_ATTENUATION, attenuate[2]*atten2scale );
        }
    }
    if ( vect[0] != orig->vect[0] || vect[1] != orig->vect[1] || vect[2] != orig->vect[2] || attenuated() != orig->attenuated() )
        SendGLPosition( gltarg );
    if (diffuse[0] != orig->diffuse[0] || diffuse[1] != orig->diffuse[1] || diffuse[2] != orig->diffuse[2] || diffuse[3]
        != orig->diffuse[3])
        glLightfv( gltarg, GL_DIFFUSE, diffuse );
    if (specular[0] != orig->specular[0] || specular[1] != orig->specular[1] || specular[2] != orig->specular[2]
        || specular[3] != orig->specular[3])
        glLightfv( gltarg, GL_SPECULAR, specular );
    if (ambient[0] != orig->ambient[0] || ambient[1] != orig->ambient[1] || ambient[2] != orig->ambient[2] || ambient[3]
        != orig->ambient[3])
        glLightfv( gltarg, GL_AMBIENT, ambient );
    orig->target = -1;
    GLLights[original].index = -1;
}

void gfx_light::Kill

(

)

Disables it (may remove from table), trashes it from GLlights. sets target to -2 (dead)

Definition at line 211 of file gl_light_state.cpp.

References Disable(), GFXLight::options, GFXLight::target, and TrashFromGLLights().

{
    Disable();     //first disables it...which _will_ remove it from the light table.
    if (target >= 0)
        TrashFromGLLights();          //then if not already done, trash from GLlights;
    target  = -2;
    options = 0;
}

int gfx_light::lightNum

(

)

Returns the number this light is in the _llights list.

Definition at line 153 of file gl_light_state.cpp.

References _llights.

Referenced by CalculateBounds(), and ClobberGLLight().

{
    int tmp = ( this-&_llights->front() );
    assert( tmp >= 0 && tmp < (int) _llights->size() );
    //assert (&(*_llights)[GLLights[target].index]==this);
    return tmp;
} //which number it is in the main scheme of things

bool gfx_light::LocalLight ( ) const

inline

Returns if this light was saved as a local light.

Definition at line 31 of file gl_light.h.

References GFX_LOCAL_LIGHT, and GFXLight::options.

Referenced by ClobberGLLight(), Disable(), Enable(), and ResetProperties().

    {
        return (options&GFX_LOCAL_LIGHT) != 0;
    }

GFXLight gfx_light::operator=

(

const GFXLight &

tmp)

assigns a GFXLight to a gfx_light

Definition at line 147 of file gl_light_state.cpp.

References VsnetOSS::memcpy().

{
    memcpy( this, &tmp, sizeof (GFXLight) );
    return tmp;
}

bool gfx_light::RemoveFromTable	(	bool	shouldremove = true,
		const GFXLight &	t = GFXLight()
	)

Removes this light from light table.

Definition at line 399 of file gl_light_state.cpp.

References CalculateBounds(), Hashtable3d< T, COLLIDETABLESIZE, COLLIDETABLEACCURACY, HUGEOBJECT >::hash_int(), LineCollideStar::lc, LineCollide::Maxi, LineCollide::Mini, and Hashtable3d< T, COLLIDETABLESIZE, COLLIDETABLEACCURACY, HUGEOBJECT >::Remove().

Referenced by Disable(), and ResetProperties().

{
    LineCollideStar tmp;
    bool err;
    LineCollide     coltarg( CalculateBounds( err ) );
    if (!shouldremove) {
        bool err2;
        LineCollide coltarg2( CalculateBounds( err2 ) );
        if ( lighttable.hash_int( coltarg2.Mini.i ) == lighttable.hash_int( coltarg.Mini.i )
            && lighttable.hash_int( coltarg2.Mini.j ) == lighttable.hash_int( coltarg.Mini.j )
            && lighttable.hash_int( coltarg2.Mini.k ) == lighttable.hash_int( coltarg.Mini.k )
            && lighttable.hash_int( coltarg2.Maxi.i ) == lighttable.hash_int( coltarg.Maxi.i )
            && lighttable.hash_int( coltarg2.Maxi.j ) == lighttable.hash_int( coltarg.Maxi.j )
            && lighttable.hash_int( coltarg2.Maxi.k ) == lighttable.hash_int( coltarg.Maxi.k ) )
            return false;
    }
    if (err)
        return false;
    tmp.lc = &coltarg;
    if ( lighttable.Remove( &coltarg, tmp ) ) {
        if (tmp.lc)
            delete tmp.lc;
        else
            assert( tmp.lc );
    }
    return true;
}

void gfx_light::ResetProperties	(	const enum LIGHT_TARGET	light_targ,
		const GFXColor &	color
	)

sets properties, making minimum GL state changes for global, for local lights, removes it from table, trashes it from GLlights, if enabled, puts it bakc in table.

Definition at line 309 of file gl_light_state.cpp.

References GFXColor::a, AddToTable(), AMBIENT, GFXLight::ambient, GFXLight::apply_attenuate(), atten0scale, atten1scale, atten2scale, ATTENUATE, GFXLight::attenuate, GFXLight::attenuated(), GFXColor::b, changed, DIFFUSE, GFXLight::diffuse, GFXColor::g, LocalLight(), VsnetOSS::memcpy(), POSITION, GFXColor::r, RemoveFromTable(), SendGLPosition(), GFXLight::SetProperties(), SPECULAR, GFXLight::specular, GFXLight::target, TrashFromGLLights(), and GFXLight::vect.

{
    bool changed = false;
    if ( LocalLight() ) {
        GFXLight t;
        memcpy( &t, this, sizeof (GFXLight) );
        t.SetProperties( light_targ, color );
        changed = RemoveFromTable( false, t );
        memcpy( this, &t, sizeof (GFXLight) );
        if (changed)
            AddToTable();
        if (target >= 0)
            TrashFromGLLights();
        return;
    }
    switch (light_targ)
    {
    case DIFFUSE:
        diffuse[0] = color.r;
        diffuse[1] = color.g;
        diffuse[2] = color.b;
        diffuse[3] = color.a;
        if (target < 0)
            break;
        glLightfv( GL_LIGHT0+target, GL_DIFFUSE, diffuse );
        break;
    case SPECULAR:
        specular[0] = color.r;
        specular[1] = color.g;
        specular[2] = color.b;
        specular[3] = color.a;
        if (target < 0)
            break;
        glLightfv( GL_LIGHT0+target, GL_SPECULAR, specular );
        break;
    case AMBIENT:
        ambient[0] = color.r;
        ambient[1] = color.g;
        ambient[2] = color.b;
        ambient[3] = color.a;
        if (target < 0)
            break;
        glLightfv( GL_LIGHT0+target, GL_AMBIENT, ambient );
        break;
    case POSITION:
        vect[0] = color.r;
        vect[1] = color.g;
        vect[2] = color.b;
        if (target < 0)
            break;
        SendGLPosition( GL_LIGHT0+target );
        break;
    default:
    case ATTENUATE:
        attenuate[0] = color.r;
        attenuate[1] = color.g;
        attenuate[2] = color.b;
        apply_attenuate( attenuated() );
        if (target < 0)
            break;
        SendGLPosition( GL_LIGHT0+target );
        glLightf( GL_LIGHT0+target, GL_CONSTANT_ATTENUATION, attenuate[0]*atten0scale );
        glLightf( GL_LIGHT0+target, GL_LINEAR_ATTENUATION, attenuate[1]*atten1scale );
        glLightf( GL_LIGHT0+target, GL_QUADRATIC_ATTENUATION, attenuate[2]*atten2scale );
        break;
    }
}

void gfx_light::SendGLPosition

(

const GLenum

target)

const

properly utilizes union to send to OGL

ClobberGLLight **** most OpenGL implementation dirty lighting if any info is changed at all having two different lights with the same stats and pos is unlikely at best

Definition at line 225 of file gl_light_state.cpp.

References v, and GFXLight::vect.

Referenced by ContextSwitchClobberLight(), FinesseClobberLight(), and ResetProperties().

{
    float v[4] = {vect[0], vect[1], vect[2], 1};
    glLightfv( target, GL_POSITION, v );
}

int& gfx_light::Target ( )

inline

Returns the target OpenGL light of this light. -1 is unassigned to a "real" light.

Definition at line 41 of file gl_light.h.

References GFXLight::target.

    {
        return target;
    }

void gfx_light::TrashFromGLLights

(

)

Trash this light from active GLLights.

Definition at line 377 of file gl_light_state.cpp.

References _llights, OpenGLL::GLL_LOCAL, OpenGLL::GLL_ON, GLLights, OpenGLLights::index, index, OpenGLLights::options, GFXLight::options, removelightfromnewpick(), and GFXLight::target.

Referenced by Disable(), Kill(), and ResetProperties().

{
    assert( target >= 0 );
    assert( (GLLights[target].options&OpenGLL::GLL_ON) == 0 );       //better be disabled so we know it's not in the table, etc
    assert( (&(*_llights)[GLLights[target].index]) == this );
    removelightfromnewpick(GLLights[target].index);
    GLLights[target].index   = -1;
    GLLights[target].options = OpenGLL::GLL_LOCAL;
    target = -1;
}

---

The documentation for this class was generated from the following files:

• src/gldrv/gl_light.h
• src/gldrv/gl_light_pick.cpp
• src/gldrv/gl_light_state.cpp