#include <aux_logo.h>

Public Member Functions
	Logo (int numberlogos, Vector center, Vector normal, float sizes, float rotations, float offset, Texture Dec, Vector Ref)

	Logo (const Logo &rval)

	~Logo ()

void	SetDecal (Texture *decal)

void	Draw (const Matrix &m)

Protected Member Functions
void	ProcessDrawQueue ()

Protected Attributes
int	refcount

Logo *	owner_of_draw_queue

vector< DrawContext > *	draw_queue

bool	will_be_drawn

Friends
class	Mesh

Detailed Description

Definition at line 33 of file aux_logo.h.

Constructor & Destructor Documentation

Logo::Logo	(	int	numberlogos,
		Vector *	center,
		Vector *	normal,
		float *	sizes,
		float *	rotations,
		float	offset,
		Texture *	Dec,
		Vector *	Ref
	)

backwards compatibility shit

Definition at line 34 of file aux_logo.cpp.

References draw_queue, GFXQUAD, i, j, k, q, refcount, Roll(), SetDecal(), Vector, will_be_drawn, and y.

 {
     offset     = 0;
     refcount   = -1;
     draw_queue = NULL;
 
     numlogos   = numberlogos;
     GFXVertex *vertices   = new GFXVertex[numlogos*4];
     GFXVertex *LogoCorner = vertices;
     //LogoCorner = new glVertex* [numlogos]; //hope to hell we have enough mem
     Vector     p, q, r, v1, v2, v3, v4; //temps
     will_be_drawn = false;
     for (int i = 0; i < numlogos; i++, LogoCorner += 4) {
         r = normal[i];
         Normalize( r );
         Vector translation = r*offset;
         if (Ref[i].i || Ref[i].j || Ref[i].k) {
             p = Ref[i];
             Normalize( p );
             ScaledCrossProduct( r, p, q );
             ::Roll( rotation[i], p, q, r );
             float  tsize   = size[i]*0.50F;
             Vector tcenter = center[i]+translation;
             v4 = p* -tsize-q*tsize+tcenter;
             v3 = p* -tsize+q*tsize+tcenter;
             v2 = p*tsize+q*tsize+tcenter;
             v1 = p*tsize-q*tsize+tcenter;
         } else {
             Vector y;
             if ( (r.i == 1 || r.i == -1) && !r.j && !r.k )
                 y = Vector( 0, 1, 0 );
             else
                 y = Vector( 1, 0, 0 );
             ScaledCrossProduct( r, y, p );
             ScaledCrossProduct( r, p, q );
             ::Roll( rotation[i], p, q, r );
             float  tsize   = size[i]*0.50F;
             Vector tcenter = center[i]+translation;
             v1 = q*tsize+tcenter;
             v2 = p* -tsize+tcenter;
             v3 = q* -tsize+tcenter;
             v4 = p*tsize+tcenter;
         }
         LogoCorner[0].SetVertex( v1 ).SetNormal( r ).SetTexCoord( 0, 0 );
         LogoCorner[1].SetVertex( v2 ).SetNormal( r ).SetTexCoord( 0, 1 );
         LogoCorner[2].SetVertex( v3 ).SetNormal( r ).SetTexCoord( 1, 1 );
         LogoCorner[3].SetVertex( v4 ).SetNormal( r ).SetTexCoord( 1, 0 );
         //LogoCorner[4] = LogoCorner[2];
         //LogoCorner[5] = LogoCorner[1];
     }
     vlist = new GFXVertexList( GFXQUAD, 4*numlogos, vertices, 4*numlogos );
     delete[] vertices;
     SetDecal( Dec );
 }

Logo::Logo ( const Logo & rval)

inline

Definition at line 56 of file aux_logo.h.

     {
         *this = rval;
     }

Logo::~Logo ( )

Definition at line 176 of file aux_logo.cpp.

References Hashtable< KEY, VALUE, SIZ >::Delete(), draw_queue, Texture::name, owner_of_draw_queue, and refcount.

 {
     if (owner_of_draw_queue != this)
         delete vlist;
     //if(LogoCorner!=NULL)
     //delete [] LogoCorner;
     if (owner_of_draw_queue != NULL) {
         if (owner_of_draw_queue != this)
             owner_of_draw_queue->refcount--;
         if (owner_of_draw_queue->refcount == 0 && owner_of_draw_queue != this)
             delete owner_of_draw_queue;
     }
     if (owner_of_draw_queue == this) {
         assert( refcount == 0 );
         decalHash.Delete( Decal->name );
         delete draw_queue;
     }
 }

Member Function Documentation

void Logo::Draw ( const Matrix & m)

Definition at line 133 of file aux_logo.cpp.

References draw_queue, owner_of_draw_queue, undrawn_logos, and will_be_drawn.

 {
     if (!numlogos)
         return;
     //Matrix m;
     //GFXGetMatrix(MODEL, m);
     draw_queue->push_back( DrawContext( m, vlist ) );
     if (!owner_of_draw_queue->will_be_drawn) {
         undrawn_logos.push_back( owner_of_draw_queue );
         owner_of_draw_queue->will_be_drawn = true;
     }
 }

void Logo::ProcessDrawQueue ( )

protected

Definition at line 146 of file aux_logo.cpp.

References GFXVertexList::BeginDrawState(), c, DEPTHWRITE, GFXVertexList::Draw(), draw_queue, GFXVertexList::EndDrawState(), g_game, VegaConfig::getVariable(), GFXBlendMode(), GFXColor4f(), GFXDisable(), GFXEnable(), GFXFALSE, GFXLoadMatrixModel(), GFXPolygonOffset(), INVSRCALPHA, LIGHTING, GFXVertexList::LoadDrawState(), DrawContext::m, Texture::MakeActive(), XMLSupport::parse_float(), SRCALPHA, TEXTURE0, TEXTURE1, game_data_t::use_logos, DrawContext::vlist, and vs_config.

Referenced by Mesh::ProcessUndrawnMeshes().

 {
     if ( !g_game.use_logos || draw_queue->empty() )
         return;
     static float offs = XMLSupport::parse_float( vs_config->getVariable( "graphics", "LogoOffset", "-1" ) );
     static float scl  = XMLSupport::parse_float( vs_config->getVariable( "graphics", "LogoOffsetScale", "-4.0" ) );
 
     GFXEnable( TEXTURE0 );
     GFXEnable( TEXTURE1 );
     Decal->MakeActive();
     GFXDisable( DEPTHWRITE );
     GFXDisable( LIGHTING );
     GFXColor4f( 1, 1, 1, 1 );
     GFXPolygonOffset( offs, scl );
     GFXBlendMode( SRCALPHA, INVSRCALPHA );
     //GFXBlendMode(ONE,ZERO);
     DrawContext c = draw_queue->back();
     c.vlist->LoadDrawState();
     while ( draw_queue->size() ) {
         c = draw_queue->back();
         draw_queue->pop_back();
         GFXLoadMatrixModel( c.m );
         c.vlist->BeginDrawState( GFXFALSE );
         c.vlist->Draw();
         c.vlist->EndDrawState( GFXFALSE );
     }
     GFXEnable( DEPTHWRITE );
     GFXPolygonOffset( 0, 0 );
 }

void Logo::SetDecal ( Texture * decal)

Definition at line 97 of file aux_logo.cpp.

References draw_queue, Hashtable< KEY, VALUE, SIZ >::Get(), Texture::name, owner_of_draw_queue, Hashtable< KEY, VALUE, SIZ >::Put(), and refcount.

Referenced by Logo().

 {
     Decal = decal;
     //Check which draw_queue to use:
     Logo *l;
     if ( ( l = decalHash.Get( decal->name ) ) != NULL ) {
         draw_queue = l->draw_queue;
         owner_of_draw_queue = l;
         l->refcount++;
     } else {
         l = new Logo( *this );         //(Logo*)malloc (sizeof (Logo));
         //memcpy (l,this,sizeof(Logo));
         decalHash.Put( decal->name, l );
         draw_queue  = l->draw_queue = new vector< DrawContext > ();
         owner_of_draw_queue = l->owner_of_draw_queue = l;
         l->refcount = 1;
     }
 }