Animation Class Reference

#include <animation.h>

Inheritance diagram for Animation:

Public Member Functions
	Animation ()
	Animation (VSFileSystem::VSFile *f, bool Rep=0, float priority=.1, enum FILTER ismipmapped=MIPMAP, bool camorient=false, bool appear_near_by_radius=false, const GFXColor &col=GFXColor(1, 1, 1, 1))
	Animation (const char *, bool Rep=0, float priority=.1, enum FILTER ismipmapped=MIPMAP, bool camorient=false, bool appear_near_by_radius=false, const GFXColor &col=GFXColor(1, 1, 1, 1))
	~Animation ()
void	Draw ()
void	SetFaceCam (bool face)
void	SetInterpolate (bool interp)
bool	CalculateOrientation (Matrix &result)
void	DrawNow (const Matrix &final_orientation)
void	DrawNoTransform (bool cross=true, bool blendoption=false)
void	DrawAsVSSprite (class VSSprite *spr)
void	SetDimensions (float wid, float hei)
void	GetDimensions (float &wid, float &hei)
QVector	Position ()
void	SetPosition (const QVector &)
void	SetOrientation (const Vector &p, const Vector &q, const Vector &r)
Public Member Functions inherited from AnimatedTexture
virtual void	setTime (double tim)
virtual double	curTime () const
virtual unsigned int	numFrames () const
virtual float	framesPerSecond () const
virtual unsigned int	numLayers () const
virtual unsigned int	numPasses () const
virtual bool	canMultiPass () const
virtual bool	constFrameRate () const
	AnimatedTexture ()
	AnimatedTexture (int stage, enum FILTER imm, bool detailtexture=false)
	AnimatedTexture (const char *file, int stage, enum FILTER imm, bool detailtexture=false)
	AnimatedTexture (VSFileSystem::VSFile &openedfile, int stage, enum FILTER imm, bool detailtexture=false)
void	Load (VSFileSystem::VSFile &f, int stage, enum FILTER ismipmapped, bool detailtex=false)
void	LoadAni (VSFileSystem::VSFile &f, int stage, enum FILTER ismipmapped, bool detailtex=false)
void	LoadVideoSource (VSFileSystem::VSFile &f)
virtual void	LoadFrame (int num)
void	Destroy ()
virtual const Texture *	Original () const
virtual Texture *	Original ()
	~AnimatedTexture ()
virtual Texture *	Clone ()
virtual void	MakeActive ()
	Binds the texture in the GFX library. More...
virtual void	MakeActive (int stage)
virtual void	MakeActive (int stage, int pass)
bool	SetupPass (int pass, int stage, const enum BLENDFUNC src, const enum BLENDFUNC dst)
bool	SetupPass (int pass, const enum BLENDFUNC src, const enum BLENDFUNC dst)
void	SetInterpolateFrames (bool set)
void	SetInterpolateTCoord (bool set)
void	SetLoopInterp (bool set)
void	SetLoop (bool set)
bool	GetInterpolateFrames () const
bool	GetInterpolateTCoord () const
bool	GetLoopInterp () const
bool	GetLoop () const
SharedPtr< Audio::Source >	GetTimeSource () const
void	SetTimeSource (SharedPtr< Audio::Source > source)
void	ClearTimeSource ()
void	Reset ()
bool	Done () const
virtual bool	LoadSuccess ()
	If the texture has loaded properly returns true. More...
Public Member Functions inherited from Texture
void	FileNotFound (const std::string &)
GFXBOOL	checkold (const std::string &s, bool shared, std::string &hashname)
	Returns if this texture is actually already loaded. More...
void	modold (const std::string &s, bool shared, std::string &hashname)
void	setold ()
	Loads the old texture. More...
bool	checkbad (const string &s)
void	setbad (const string &s)
void	InitTexture ()
	Inits the class with default values. More...
int	Bind (Texture *other, int maxdimension=65536, GFXBOOL detailtexture=GFXFALSE)
	Binds this texture to the same name as the given texture - for multipart textures. More...
	Texture (int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE)
	Creates an unbounded texture. Set data and dimensions before binding. Or explicitly load a file. More...
	Texture (const char *, const char *, int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, float alpha=1, int zeroval=0, GFXBOOL force=GFXFALSE, int max_dimension_size=65536, GFXBOOL detail_texture=GFXFALSE, GFXBOOL nocache=false, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE, Texture *main=0)
	Creates a texture with a single bitmap as color data and another grayscale .bmp as alpha data. More...
	Texture (const char *FileName, int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, GFXBOOL force=GFXFALSE, int max_dimension_size=65536, GFXBOOL detail_texture=GFXFALSE, GFXBOOL nocache=false, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE, Texture *main=0)
	Creates a texture with only color data as a single bitmap. More...
	Texture (VSFileSystem::VSFile *f, int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, GFXBOOL force=GFXFALSE, int max_dimension_size=65536, GFXBOOL detail_texture=GFXFALSE, GFXBOOL nocache=false, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE, Texture *main=0)
void	Load (const char *, const char *, int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, float alpha=1, int zeroval=0, GFXBOOL force=GFXFALSE, int max_dimension_size=65536, GFXBOOL detail_texture=GFXFALSE, GFXBOOL nocache=false, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE, Texture *main=0)
void	Load (const char *FileName, int stage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET target=TEXTURE2D, enum TEXTURE_IMAGE_TARGET imagetarget=TEXTURE_2D, GFXBOOL force=GFXFALSE, int max_dimension_size=65536, GFXBOOL detail_texture=GFXFALSE, GFXBOOL nocache=false, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE, Texture *main=0)
virtual	~Texture ()
	Texture copy constructor that increases appropriate refcounts. More...
int	getStage () const
int	getFilter () const
int	getTarget () const
int	getImageTarget () const
bool	operator< (const Texture &b) const
	A way to sort the texture by the original address (to make sure like textures stick togehter. More...
bool	operator== (const Texture &b) const
	A way to test if the texture is equal to another based on original values. More...
void	setReference (Texture *other)
	Make this instance a reference of "other". More...
virtual void	Prioritize (float)
	Changes priority of texture. More...

Static Public Member Functions
static void	ProcessDrawQueue (std::vector< Animation * > &, float)
static void	ProcessDrawQueue ()
static bool	NeedsProcessDrawQueue ()
static void	ProcessFarDrawQueue (float)
static bool	NeedsProcessFarDrawQueue ()
Static Public Member Functions inherited from AnimatedTexture
static void	UpdateAllPhysics ()
static void	UpdateAllFrame ()
static AnimatedTexture *	CreateVideoTexture (const std::string &fname, int stage=0, enum FILTER ismipmapped=BILINEAR, bool detailtex=false)
Static Public Member Functions inherited from Texture
static Texture *	Exists (std::string s)
	Whether or not the string exists as a texture. More...
static Texture *	Exists (std::string s, std::string a)
	Whether or not the color and alpha data already exist. More...

Additional Inherited Members
Public Attributes inherited from Texture
StringPool::Reference	texfilename
	The file name used to load this texture. More...
enum FILTER	ismipmapped
	the filter mode of this texture More...
unsigned char *	data
	The data of this texture (used in between functions, deleted) More...
int	name
	The GFXname of this texture. More...
int	stage
	The multitexture stage of this texture. More...
Vector	mintcoord
	The minimum/maximum texturing coordinates for this texture (have in mind that it is not always enforce, ie. for meshes) (i=s, j=t, k=u) More...
Vector	maxtcoord
Texture *	original
	The original data that would represent this texture. More...
bool	bound
	For re-biding. More...
uint	boundSizeX
uint	boundSizeY
VSImageMode	boundMode
int	refcount
	The number of references on the original data. More...
enum TEXTURE_TARGET	texture_target
	The target this will go to (cubemap or otherwise) More...
enum TEXTURE_IMAGE_TARGET	image_target
enum ADDRESSMODE	address_mode
	The address mode being used with this texture. More...
Protected Member Functions inherited from Texture
int	Bind (int maxdimension, GFXBOOL detailtexture)
	Binds this texture to GFX library. More...
void	UnBind ()
	UnBinds from GFX library. More...
void	Transfer (int maxdimension, GFXBOOL detailtexture)
	Transfers this texture to GFX library. More...
Protected Attributes inherited from AnimatedTexture
unsigned int	numframes
float	timeperframe
unsigned int	active
unsigned int	nextactive
float	active_fraction
double	curtime
double	lastcurtime
double	lastrealtime
bool	constframerate
bool	done

Detailed Description

Definition at line 41 of file animation.h.

Constructor & Destructor Documentation

Animation::Animation

(

)

Definition at line 56 of file animation.cpp.

References VSCONSTRUCT2.

{
    VSCONSTRUCT2( 'a' )
    height = 0.001F;
    width  = 0.001F;
}

Animation::Animation	(	VSFileSystem::VSFile *	f,
		bool	Rep = 0,
		float	priority = .1,
		enum FILTER	ismipmapped = MIPMAP,
		bool	camorient = false,
		bool	appear_near_by_radius = false,
		const GFXColor &	col = GFXColor( 1, 1, 1,                                                                                             1 )
	)

Definition at line 72 of file animation.cpp.

                                          : mycolor( c )
{}

Animation::Animation	(	const char *	FileName,
		bool	Rep = 0,
		float	priority = .1,
		enum FILTER	ismipmapped = MIPMAP,
		bool	camorient = false,
		bool	appear_near_by_radius = false,
		const GFXColor &	col = GFXColor( 1, 1, 1,                                                                                  1 )
	)

Definition at line 81 of file animation.cpp.

References ani_alpha, ani_close, ani_repeat, ani_up, VSFileSystem::AnimFile, VSFileSystem::VSFile::Close(), f, VSFileSystem::VSFile::Fscanf(), Identity(), AnimatedTexture::Load(), VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), AnimatedTexture::SetLoop(), AnimatedTexture::SetLoopInterp(), and VSCONSTRUCT2.

                                          : mycolor( c )
{
    Identity( local_transformation );
    VSCONSTRUCT2( 'a' )
    //repeat = Rep;
    options = 0;
    if (Rep)
        options |= ani_repeat;
    if (camorient)
        options |= ani_up;
    if (appear_near_by_radius)
        options |= ani_close;
    SetLoop( Rep );     //setup AnimatedTexture's loop flag - NOTE: Load() will leave it like this unless a force(No)Loop option is present
    SetLoopInterp( Rep );     //Default interpolation method == looping method
    VSFile  f;
    VSError err = f.OpenReadOnly( FileName, AnimFile );
    if (err > Ok) {
        //load success already set false
    } else {
        f.Fscanf( "%f %f", &width, &height );
        if (width > 0)
            options |= ani_alpha;
        width  = fabs( width*0.5F );
        height = height*0.5F;
        Load( f, 0, ismipmapped );
        f.Close();
    }
    //VSFileSystem::ResetCurrentPath();
}

Animation::~Animation

(

)

Definition at line 116 of file animation.cpp.

References animationdrawqueue, far_animationdrawqueue, i, and VSDESTRUCT2.

{
    vector< Animation* >::iterator i;
    while ( ( i =
                 std::find( far_animationdrawqueue.begin(), far_animationdrawqueue.end(),
                            this ) ) != far_animationdrawqueue.end() )
        far_animationdrawqueue.erase( i );
    while ( ( i = std::find( animationdrawqueue.begin(), animationdrawqueue.end(), this ) ) != animationdrawqueue.end() )
        animationdrawqueue.erase( i );
    VSDESTRUCT2
}

Member Function Documentation

bool Animation::CalculateOrientation

(

Matrix &

result)

Definition at line 214 of file animation.cpp.

References ani_close, ani_up, VegaConfig::getVariable(), XMLSupport::parse_float(), Position(), QVector, Vector, VectorAndPositionToMatrix(), and vs_config.

{
    Vector  camp, camq, camr;
    QVector pos( Position() );
    float   hei    = height;
    float   wid    = width;
    static float HaloOffset = XMLSupport::parse_float( vs_config->getVariable( "graphics", "HaloOffset", ".1" ) );
    bool    retval =
        ::CalculateOrientation( pos,
                                camp,
                                camq,
                                camr,
                                wid,
                                hei,
                                (options&ani_close) ? HaloOffset : 0,
                                false,
                                (options&ani_up) ? NULL : &local_transformation );

    /*
     *  Camera* TempCam = _Universe->AccessCamera();
     *  TempCam->GetPQR(camp,camq,camr);
     *  if (!camup){
     *  Vector q1 (local_transformation[1],local_transformation[5],local_transformation[9]);
     *  Vector p1 ((q1.Dot(camq))*camq);
     *  camq = (q1.Dot(camp))*camp+p1;
     *  Vector posit;
     *  TempCam->GetPosition (posit);
     *  camr.i = -local_transformation[12]+posit.i;
     *  camr.j = -local_transformation[13]+posit.j;
     *  camr.k = -local_transformation[14]+posit.k;
     *  Normalize (camr);
     *  ScaledCrossProduct (camq,camr,camp);
     *  ScaledCrossProduct (camr,camp,camq);
     *  //if the vectors are linearly dependant we're phucked :) fun fun fun
     *  }
     */
    VectorAndPositionToMatrix( result, camp, camq, camr, pos );
    return retval;
}

void Animation::Draw

(

)

Definition at line 454 of file animation.cpp.

References _Universe, Universe::AccessCamera(), animationdrawqueue, far_animationdrawqueue, g_game, Camera::GetPosition(), Camera::GetR(), VegaConfig::getVariable(), Magnitude(), XMLSupport::parse_float(), Position(), QVector, R, game_data_t::use_animations, game_data_t::use_textures, Vector, vs_config, and game_data_t::zfar.

Referenced by CoordinateSelect::Draw(), LocationSelect::Draw(), and GamePlanet::Draw().

{
    if (g_game.use_animations != 0 || g_game.use_textures != 0) {
        Vector  camp, camq, camr;
        QVector pos( Position() );
        float   hei = height;
        float   wid = width;
        static float HaloOffset = XMLSupport::parse_float( vs_config->getVariable( "graphics", "HaloOffset", ".1" ) );

        
        //Why do all this if we can use ::CalculateOrientation?
        //-- well one reason is that the code change broke it :-/  Until suns display properly or we switch to ogre we should keep it as it was (problem was, flare wouldn't display--- or would display behind the sun)
        QVector R( _Universe->AccessCamera()->GetR().i, _Universe->AccessCamera()->GetR().j,
                   _Universe->AccessCamera()->GetR().k );
        static float too_far_dist = XMLSupport::parse_float( vs_config->getVariable( "graphics", "anim_far_percent", ".8" ) );
        if ( ( /*R.Dot*/ ( Position()
                          -_Universe->AccessCamera()->GetPosition() ).Magnitude()+HaloOffset
              *(height > width ? height : width) ) < too_far_dist*g_game.zfar )
            //if (::CalculateOrientation (pos,camp,camq,camr,wid,hei,(options&ani_close)?HaloOffset:0,false)) {ss
            animationdrawqueue.push_back( this );
        else
            far_animationdrawqueue.push_back( this );
    }
}

void Animation::DrawAsVSSprite

(

class VSSprite *

spr)

Definition at line 309 of file animation.cpp.

References ani_alpha, CULLFACE, VSSprite::DrawHere(), g_game, GFXBegin(), GFXBlendMode(), GFXDisable(), GFXEnable(), GFXEnd(), GFXGetBlendMode(), GFXMODULATETEXTURE, GFXPopBlendMode(), GFXPushBlendMode(), GFXQUAD, GFXTexCoord2f(), GFXTexCoord4f(), GFXTextureCoordGenMode(), GFXTextureEnv(), GFXToggleTexture(), GFXVertexf(), gl_options, INVSRCALPHA, AnimatedTexture::MakeActive(), Texture::maxtcoord, Texture::mintcoord, gl_options_t::Multitexture, NO_GEN, AnimatedTexture::numLayers(), AnimatedTexture::numPasses(), ONE, AnimatedTexture::SetupPass(), SRCALPHA, game_data_t::use_animations, game_data_t::use_textures, Vector, and ZERO.

{
    if (!spr)
        return;
    if (g_game.use_animations != 0 || g_game.use_textures != 0) {
        //unsigned char alphamaps=ani_alpha;
        GFXPushBlendMode();
        if (options&ani_alpha)
            GFXBlendMode( SRCALPHA, INVSRCALPHA );
        else
            GFXBlendMode( ONE, ZERO );
        size_t lyr;
        size_t numlayers = numLayers();
        bool multitex = (numlayers > 1);
        size_t numpasses = numPasses();
        float     ms = mintcoord.i, Ms = maxtcoord.i;
        float     mt = mintcoord.j, Mt = maxtcoord.j;
        GFXDisable( CULLFACE );
        Vector    ll, lr, ur, ul;
        spr->DrawHere( ll, lr, ur, ul );
        BLENDFUNC src, dst;
        GFXGetBlendMode( src, dst );
        for (lyr = 0; (lyr < gl_options.Multitexture) || (lyr < numlayers); lyr++) {
            GFXToggleTexture( (lyr < numlayers), lyr );
            if (lyr < numlayers) GFXTextureCoordGenMode( lyr, NO_GEN, NULL, NULL );
        }
        for (size_t pass = 0; pass < numpasses; pass++)
            if ( SetupPass( pass, 0, src, dst ) ) {
                MakeActive( 0, pass );
                GFXTextureEnv( 0, GFXMODULATETEXTURE );
                GFXBegin( GFXQUAD );
                if (!multitex) GFXTexCoord2f( ms, Mt );

                else GFXTexCoord4f( ms, Mt, ms, Mt );
                GFXVertexf( ll );
                if (!multitex) GFXTexCoord2f( Ms, Mt );

                else GFXTexCoord4f( Ms, Mt, Ms, Mt );
                GFXVertexf( lr );
                if (!multitex) GFXTexCoord2f( Ms, mt );

                else GFXTexCoord4f( Ms, mt, Ms, mt );
                GFXVertexf( ur );
                if (!multitex) GFXTexCoord2f( ms, mt );

                else GFXTexCoord4f( ms, mt, ms, mt );
                GFXVertexf( ul );
                GFXEnd();
            }
        SetupPass( -1, 0, src, dst );
        for (lyr = 0; lyr < numlayers; lyr++)
            GFXToggleTexture( false, lyr );
        GFXEnable( CULLFACE );
        GFXPopBlendMode();
    }
}

void Animation::DrawNoTransform	(	bool	cross = true,
		bool	blendoption = false
	)

Definition at line 365 of file animation.cpp.

References ani_alpha, ani_repeat, DEPTHWRITE, AnimatedTexture::Done(), f, g_game, GFXBegin(), GFXBlendMode(), GFXDisable(), GFXEnable(), GFXEnd(), GFXGetBlendMode(), GFXMODULATETEXTURE, GFXQUAD, GFXTexCoord2f(), GFXTexCoord4f(), GFXTextureCoordGenMode(), GFXTextureEnv(), GFXToggleTexture(), GFXVertex3f(), gl_options, INVSRCALPHA, AnimatedTexture::MakeActive(), Texture::maxtcoord, Texture::mintcoord, gl_options_t::Multitexture, NO_GEN, AnimatedTexture::numLayers(), AnimatedTexture::numPasses(), ONE, AnimatedTexture::SetupPass(), SRCALPHA, game_data_t::use_animations, and game_data_t::use_textures.

Referenced by Bolt::Draw().

{
    bool doitagain = false;
    if (g_game.use_animations == 0 && g_game.use_textures == 0) {} else if ( !Done() || (options&ani_repeat) ) {
        size_t lyr;
        size_t numlayers = numLayers();
        bool  multitex  = (numlayers > 1);
        size_t numpasses = numPasses();
        float ms = mintcoord.i, Ms = maxtcoord.i;
        float mt = mintcoord.j, Mt = maxtcoord.j;
        if (blendoption) {
            if (options&ani_alpha) {
                GFXEnable( DEPTHWRITE );
                GFXBlendMode( SRCALPHA, INVSRCALPHA );
            } else {
                GFXBlendMode( ONE, ONE );
            }
        }
        BLENDFUNC src, dst;
        GFXGetBlendMode( src, dst );
        for (lyr = 0; (lyr < gl_options.Multitexture) || (lyr < numlayers); lyr++) {
            GFXToggleTexture( (lyr < numlayers), lyr );
            if (lyr < numlayers) GFXTextureCoordGenMode( lyr, NO_GEN, NULL, NULL );
        }
        for (size_t pass = 0; pass < numpasses; pass++)
            if ( SetupPass( pass, 0, src, dst ) ) {
                MakeActive( 0, pass );
                GFXTextureEnv( 0, GFXMODULATETEXTURE );
                GFXBegin( GFXQUAD );
                if (!multitex) GFXTexCoord2f( ms, Mt );

                else GFXTexCoord4f( ms, Mt, ms, Mt );
                GFXVertex3f( -width, -height, 0.0f );                 //lower left
                if (!multitex) GFXTexCoord2f( Ms, Mt );

                else GFXTexCoord4f( Ms, Mt, Ms, Mt );
                GFXVertex3f( width, -height, 0.0f );                 //upper left
                if (!multitex) GFXTexCoord2f( Ms, mt );

                else GFXTexCoord4f( Ms, mt, Ms, mt );
                GFXVertex3f( width, height, 0.0f );                 //upper right
                if (!multitex) GFXTexCoord2f( ms, mt );

                else GFXTexCoord4f( ms, mt, ms, mt );
                GFXVertex3f( -width, height, 0.0f );                 //lower right
                if (cross) {
                    if (!multitex) GFXTexCoord2f( ms, Mt );

                    else GFXTexCoord4f( ms, Mt, ms, Mt );
                    GFXVertex3f( -width, 0.0f, -height );                     //lower left
                    if (!multitex) GFXTexCoord2f( Ms, Mt );

                    else GFXTexCoord4f( Ms, Mt, Ms, Mt );
                    GFXVertex3f( width, 0.0f, -height );                     //upper left
                    if (!multitex) GFXTexCoord2f( Ms, mt );

                    else GFXTexCoord4f( Ms, mt, Ms, mt );
                    GFXVertex3f( width, 0.0f, height );                     //upper right
                    if (!multitex) GFXTexCoord2f( ms, mt );

                    else GFXTexCoord4f( ms, mt, ms, mt );
                    GFXVertex3f( -width, 0.0f, height );                     //lower right
                    if (!multitex) GFXTexCoord2f( ms, Mt );

                    else GFXTexCoord4f( ms, Mt, ms, Mt );
                    GFXVertex3f( 0.0f, -height, -height );                     //lower left
                    if (!multitex) GFXTexCoord2f( Ms, Mt );

                    else GFXTexCoord4f( Ms, Mt, Ms, Mt );
                    GFXVertex3f( 0.0f, height, -height );                     //upper left
                    if (!multitex) GFXTexCoord2f( Ms, mt );

                    else GFXTexCoord4f( Ms, mt, Ms, mt );
                    GFXVertex3f( 0.0f, height, height );                     //upper right
                    if (!multitex) GFXTexCoord2f( ms, mt );

                    else GFXTexCoord4f( ms, mt, ms, mt );
                    GFXVertex3f( 0.0f, -height, height );                     //lower right
                }
                GFXEnd();
            }
        SetupPass( -1, 0, src, dst );
        for (lyr = 0; lyr < numlayers; lyr++)
            GFXToggleTexture( false, lyr );
        if (blendoption)
            if (options&ani_alpha)
                GFXDisable( DEPTHWRITE );
    }
}

void Animation::DrawNow

(

const Matrix &

final_orientation)

Definition at line 253 of file animation.cpp.

References ani_repeat, AnimatedTexture::Done(), f, g_game, GFXBegin(), GFXEnd(), GFXGetBlendMode(), GFXLoadMatrixModel(), GFXMODULATETEXTURE, GFXQUAD, GFXTexCoord2f(), GFXTexCoord4f(), GFXTextureCoordGenMode(), GFXTextureEnv(), GFXToggleTexture(), GFXVertex3f(), gl_options, AnimatedTexture::MakeActive(), Texture::maxtcoord, Texture::mintcoord, gl_options_t::Multitexture, NO_GEN, AnimatedTexture::numLayers(), AnimatedTexture::numPasses(), AnimatedTexture::SetupPass(), game_data_t::use_animations, and game_data_t::use_textures.

Referenced by bootstrap_draw().

{
//  if (g_game.use_animations == 0 && g_game.use_textures == 0)
//  {
//  }
//  else if ( !Done() || (options&ani_repeat) )
//  {  //chuck_starchaser simplifying...
    if ( (g_game.use_animations || g_game.use_textures) && (!Done() || (options&ani_repeat)) )
    {
        GFXLoadMatrixModel( final_orientation );
        size_t lyr;
        size_t numlayers = numLayers();
        bool multitex = (numlayers > 1);
        size_t numpasses = numPasses();
        float     ms = mintcoord.i, Ms = maxtcoord.i;
        float     mt = mintcoord.j, Mt = maxtcoord.j;
        BLENDFUNC src, dst;
        GFXGetBlendMode( src, dst );
        for (lyr = 0; (lyr < gl_options.Multitexture) || (lyr < numlayers); lyr++) {
            GFXToggleTexture( (lyr < numlayers), lyr );
            if (lyr < numlayers)
                GFXTextureCoordGenMode( lyr, NO_GEN, NULL, NULL );
        }
        for (size_t pass = 0; pass < numpasses; pass++) {
            if ( SetupPass( pass, 0, src, dst ) ) {
                MakeActive( 0, pass );
                GFXTextureEnv( 0, GFXMODULATETEXTURE );
                GFXBegin( GFXQUAD );
                if (!multitex)
                    GFXTexCoord2f( ms, Mt );
                else
                    GFXTexCoord4f( ms, Mt, ms, Mt );
                GFXVertex3f( -width, -height, 0.0f );                 //lower left
                if (!multitex)
                    GFXTexCoord2f( Ms, Mt );
                else
                    GFXTexCoord4f( Ms, Mt, Ms, Mt );
                GFXVertex3f( width, -height, 0.0f );                 //upper left
                if (!multitex)
                    GFXTexCoord2f( Ms, mt );
                else
                    GFXTexCoord4f( Ms, mt, Ms, mt );
                GFXVertex3f( width, height, 0.0f );                 //upper right
                if (!multitex)
                    GFXTexCoord2f( ms, mt );
                else
                    GFXTexCoord4f( ms, mt, ms, mt );
                GFXVertex3f( -width, height, 0.0f );                 //lower right
                GFXEnd();
            }
        }
        for (lyr = 0; lyr < numlayers; lyr++)
            GFXToggleTexture( false, lyr );
        SetupPass( -1, 0, src, dst );
    }
}

void Animation::GetDimensions	(	float &	wid,
		float &	hei
	)

Definition at line 144 of file animation.cpp.

{
    wid = width;
    hei = height;
}

bool Animation::NeedsProcessDrawQueue ( )

static

Definition at line 159 of file animation.cpp.

References AnimationsLeftInQueue().

{
    return AnimationsLeftInQueue();
}

bool Animation::NeedsProcessFarDrawQueue ( )

static

Definition at line 173 of file animation.cpp.

References AnimationsLeftInFarQueue().

{
    return AnimationsLeftInFarQueue();
}

QVector Animation::Position

(

)

Definition at line 135 of file animation.cpp.

References Matrix::p.

Referenced by CalculateOrientation(), Draw(), and ProcessDrawQueue().

{
    return local_transformation.p;
}

void Animation::ProcessDrawQueue ( std::vector< Animation * > &  animationdrawqueue, float  limit  )

static

Definition at line 177 of file animation.cpp.

References _Universe, Universe::AccessCamera(), ani_alpha, FOG_OFF, g_game, Camera::GetPosition(), GFXBlendMode(), GFXColorf(), GFXFogMode(), i, INVSRCALPHA, j, Magnitude(), ONE, Position(), QVector, SRCALPHA, game_data_t::use_animations, and game_data_t::use_textures.

{
    if (g_game.use_animations == 0 && g_game.use_textures == 0)
        return;
    unsigned char alphamaps = ani_alpha;
    int i, j;     //NOT UNSIGNED
    for (i = animationdrawqueue.size()-1; i >= 0; i--) {
        GFXColorf( animationdrawqueue[i]->mycolor );         //fixme, should we need this? we get som egreenie explosions
        Matrix result;
        if ( alphamaps != (animationdrawqueue[i]->options&ani_alpha) ) {
            alphamaps = (animationdrawqueue[i]->options&ani_alpha);
            GFXBlendMode( (alphamaps != 0) ? SRCALPHA : ONE, (alphamaps != 0) ? INVSRCALPHA : ONE );
        }
        QVector campos = _Universe->AccessCamera()->GetPosition();
        animationdrawqueue[i]->CalculateOrientation( result );
        if ( (limit
              <= -FLT_MAX) || (animationdrawqueue[i]->Position()-campos).Magnitude()-animationdrawqueue[i]->height > limit ) {
            //other way was inconsistent about what was far and what was not--need to use the same test for putting to far queueu and drawing it--otherwise graphical glitches
            GFXFogMode( FOG_OFF );
            animationdrawqueue[i]->DrawNow( result );
            animationdrawqueue[i] = 0;             //Flag for deletion: gets called multiple times with decreasing values, and eventually is called with limit=-FLT_MAX.
        }
    }
    //Delete flagged ones
    i = 0;
    while (i < static_cast<int>(animationdrawqueue.size()) && animationdrawqueue[i])
        ++i;
    j = i;
    while ( i < static_cast<int>(animationdrawqueue.size()) ) {
        while (i < static_cast<int>(animationdrawqueue.size()) && !animationdrawqueue[i])
            ++i;
        while (i < static_cast<int>(animationdrawqueue.size()) && animationdrawqueue[i])
            animationdrawqueue[j++] = animationdrawqueue[i++];
    }
    if( j >= 0 )
        animationdrawqueue.resize( j );
}

void Animation::ProcessDrawQueue ( )

static

Definition at line 150 of file animation.cpp.

References animationdrawqueue, DEPTHWRITE, GFXBlendMode(), GFXDisable(), GFXEnable(), INVSRCALPHA, LIGHTING, SRCALPHA, TEXTURE0, and TEXTURE1.

Referenced by GameStarSystem::Draw(), and ProcessFarDrawQueue().

{
    GFXBlendMode( SRCALPHA, INVSRCALPHA );
    GFXDisable( LIGHTING );
    GFXEnable( TEXTURE0 );
    GFXDisable( TEXTURE1 );
    GFXDisable( DEPTHWRITE );
    ProcessDrawQueue( animationdrawqueue, -FLT_MAX );
}

void Animation::ProcessFarDrawQueue ( float  farval)

static

Definition at line 163 of file animation.cpp.

References far_animationdrawqueue, GFXBlendMode(), GFXDisable(), GFXEnable(), INVSRCALPHA, LIGHTING, ProcessDrawQueue(), SRCALPHA, TEXTURE0, and TEXTURE1.

Referenced by Mesh::ProcessZFarMeshes().

{
    //set farshit
    GFXBlendMode( SRCALPHA, INVSRCALPHA );
    GFXDisable( LIGHTING );
    GFXEnable( TEXTURE0 );
    GFXDisable( TEXTURE1 );

    ProcessDrawQueue( far_animationdrawqueue, farval );
}

void Animation::SetDimensions	(	float	wid,
		float	hei
	)

Definition at line 139 of file animation.cpp.

Referenced by Bolt::Draw(), and GameUnit< UnitType >::Explode().

{
    width  = wid;
    height = hei;
}

void Animation::SetFaceCam

(

bool

face)

Definition at line 62 of file animation.cpp.

References ani_up.

Referenced by GameUnit< UnitType >::Explode().

{
    if (face)
        options |= ani_up;
    else
        options &= (~ani_up);
}

void Animation::SetInterpolate

(

bool

interp)

void Animation::SetOrientation	(	const Vector &	p,
		const Vector &	q,
		const Vector &	r
	)

Definition at line 131 of file animation.cpp.

References Matrix::p, and VectorAndPositionToMatrix().

Referenced by GamePlanet::Draw(), and GameUnit< UnitType >::Explode().

{
    VectorAndPositionToMatrix( local_transformation, p, q, r, local_transformation.p );
}

void Animation::SetPosition

(

const QVector &

p)

Definition at line 127 of file animation.cpp.

References Matrix::p.

Referenced by CoordinateSelect::Draw(), LocationSelect::Draw(), and GamePlanet::Draw().

{
    local_transformation.p = p;
}

---

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

• src/gfx/animation.h
• src/gfx/animation.cpp