AnimatedTexture Class Reference

#include <ani_texture.h>

Inheritance diagram for AnimatedTexture:

Public Member Functions
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	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...

Protected Attributes
unsigned int	numframes
float	timeperframe
unsigned int	active
unsigned int	nextactive
float	active_fraction
double	curtime
double	lastcurtime
double	lastrealtime
bool	constframerate
bool	done

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...

Detailed Description

Definition at line 14 of file ani_texture.h.

Constructor & Destructor Documentation

AnimatedTexture::AnimatedTexture

(

)

Definition at line 377 of file ani_texture.cpp.

Referenced by Clone(), and CreateVideoTexture().

{
    AniInit();
}

AnimatedTexture::AnimatedTexture	(	int	stage,
		enum FILTER	imm,
		bool	detailtexture = false
	)

Definition at line 328 of file ani_texture.cpp.

                                                                             :
    Texture( stage, imm )
{
    AniInit();
}

AnimatedTexture::AnimatedTexture	(	const char *	file,
		int	stage,
		enum FILTER	imm,
		bool	detailtexture = false
	)

Definition at line 265 of file ani_texture.cpp.

References VSFileSystem::AnimFile, VSFileSystem::VSFile::Close(), f, VSFileSystem::VSFile::Fscanf(), height, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), and width.

{
    AniInit();
    VSFile  f;
    VSError err = f.OpenReadOnly( file, AnimFile );
    //bool setdir=false;
    if (err <= Ok) {
        float width, height;
        f.Fscanf( "%f %f", &width, &height );         //it's actually an animation in global animation shares
        //setdir=true;
    }
    if (err <= Ok) {
        Load( f, stage, imm, detailtex );
        f.Close();
    } else {
        loadSuccess = false;
        /*
         *  if (setdir) {
         *  VSFileSystem::vs_resetdir();
         *  }
         */
    }
}

AnimatedTexture::AnimatedTexture	(	VSFileSystem::VSFile &	openedfile,
		int	stage,
		enum FILTER	imm,
		bool	detailtexture = false
	)

Definition at line 322 of file ani_texture.cpp.

{
    AniInit();
    Load( fp, stage, imm, detailtex );
}

AnimatedTexture::~AnimatedTexture

(

)

Definition at line 369 of file ani_texture.cpp.

References active, Texture::data, and Destroy().

{
    Destroy();
    data    = NULL;
    active  = 0;
    palette = NULL;
}

Member Function Documentation

virtual bool AnimatedTexture::canMultiPass ( ) const

inlinevirtual

Reimplemented from Texture.

Definition at line 90 of file ani_texture.h.

    {
        return true;
    }

void AnimatedTexture::ClearTimeSource

(

)

Definition at line 747 of file ani_texture.cpp.

{
    timeSource.reset();
    options &= ~optSoundTiming;
}

Texture * AnimatedTexture::Clone ( )

virtual

Reimplemented from Texture.

Definition at line 344 of file ani_texture.cpp.

References AnimatedTexture(), anis, Texture::bound, Texture::Clone(), f, i, LoadVideoSource(), Texture::name, numframes, and VSFileSystem::VSFile::OpenReadOnly().

{
    AnimatedTexture *retval = new AnimatedTexture();
    if (Decal) {
        *retval = *this;
        int nf = vidMode ? 1 : numframes;
        retval->Decal = new Texture*[nf];
        for (int i = 0; i < nf; i++)
            retval->Decal[i] = Decal[i]->Clone();
    } else if (vidSource) {
        *retval = *this;
    }
    if (vidSource) {
        retval->name  = -1;
        retval->bound = false;
        VSFileSystem::VSFile f;
        f.OpenReadOnly( wrapper_file_path, wrapper_file_type );
        retval->LoadVideoSource( f );
    } else if (Decal) {
        //LoadVideoSource adds to anis, otherwise we'll have to add ourselves
        anis.insert( retval );
    }
    return retval;
}

virtual bool AnimatedTexture::constFrameRate ( ) const

inlinevirtual

Reimplemented from Texture.

Definition at line 95 of file ani_texture.h.

References constframerate.

    {
        return constframerate;
    }

AnimatedTexture * AnimatedTexture::CreateVideoTexture ( const std::string &  fname, int  stage = 0, enum FILTER  ismipmapped = BILINEAR, bool  detailtex = false  )

static

Definition at line 487 of file ani_texture.cpp.

References AnimatedTexture(), f, fprintf, LoadVideoSource(), VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), SetLoop(), and VSFileSystem::VideoFile.

Referenced by BaseInterface::Room::BaseVSMovie::SetMovie().

{
    AnimatedTexture     *rv = new AnimatedTexture( stage, ismipmapped, detailtex );
    VSFileSystem::VSFile f;
    VSError err = f.OpenReadOnly( fname, VSFileSystem::VideoFile );
    if (err <= Ok)
        rv->LoadVideoSource( f );
    else
        fprintf( stderr, "CreateVideoTexture could not find %s\n", fname.c_str() );
    
    // Videos usually don't want to be looped, so set non-looping as default
    rv->SetLoop(false);
    
    return rv;
}

virtual double AnimatedTexture::curTime ( ) const

inlinevirtual

Reimplemented from Texture.

Definition at line 71 of file ani_texture.h.

References curtime.

Referenced by UpdateAllFrame().

    {
        return curtime;
    }

void AnimatedTexture::Destroy

(

)

Definition at line 382 of file ani_texture.cpp.

References anis, i, and numframes.

Referenced by ~AnimatedTexture().

{
    anis.erase( this );
    if (vidSource) {
        delete vidSource;
        vidSource = 0;
    }
    if (Decal) {
        int i, nf;
        nf = vidMode ? 1 : numframes;
        for (i = 0; i < nf; i++)
            delete Decal[i];
        delete[] Decal;
        Decal = NULL;
    }
}

bool AnimatedTexture::Done

(

)

const

Definition at line 248 of file ani_texture.cpp.

References curtime, done, numframes, and timeperframe.

Referenced by VDU::CheckCommAnimation(), VDU::Draw(), Animation::DrawNoTransform(), Animation::DrawNow(), and VDU::GetCommunicating().

{
    //return physicsactive<0;
    //Explosions aren't working right, and this would fix them.
    //I don't see the reason for using physics frames as reference, all AnimatedTextures
    //I've seen are gaphic-only entities (bolts use their own time-keeping system, for instance)
    //If I'm wrong, and the above line is crucial, well... feel free to fix it.
    return vidSource ? done : curtime >= numframes*timeperframe;
}

virtual float AnimatedTexture::framesPerSecond ( ) const

inlinevirtual

Reimplemented from Texture.

Definition at line 81 of file ani_texture.h.

References timeperframe.

Referenced by SpriteStarVlist::SpriteStarVlist().

    {
        return 1/timeperframe;
    }

bool AnimatedTexture::GetInterpolateFrames ( ) const

inline

Definition at line 157 of file ani_texture.h.

Referenced by MakeActive(), numLayers(), numPasses(), and SetupPass().

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

bool AnimatedTexture::GetInterpolateTCoord ( ) const

inline

Definition at line 162 of file ani_texture.h.

Referenced by MakeActive().

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

bool AnimatedTexture::GetLoop ( ) const

inline

Definition at line 172 of file ani_texture.h.

Referenced by MakeActive().

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

bool AnimatedTexture::GetLoopInterp ( ) const

inline

Definition at line 167 of file ani_texture.h.

Referenced by MakeActive().

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

SharedPtr<Audio::Source> AnimatedTexture::GetTimeSource ( ) const

inline

Definition at line 177 of file ani_texture.h.

Referenced by UpdateAllFrame().

    {
        return (options&optSoundTiming) ? timeSource : SharedPtr<Audio::Source>();
    }

void AnimatedTexture::Load	(	VSFileSystem::VSFile &	f,
		int	stage,
		enum FILTER	ismipmapped,
		bool	detailtex = false
	)

Definition at line 424 of file ani_texture.cpp.

References curtime, VSFileSystem::VSFile::GetType(), LoadAni(), LoadVideoSource(), and VSFileSystem::VideoFile.

Referenced by Animation::Animation().

{
    curtime = 0;
    frames.clear();
    frames_maxtc.clear();
    frames_mintc.clear();
    if (f.GetType() == VSFileSystem::VideoFile)
        LoadVideoSource( f );
    else
        LoadAni( f, stage, ismipmapped, detailtex );
}

void AnimatedTexture::LoadAni	(	VSFileSystem::VSFile &	f,
		int	stage,
		enum FILTER	ismipmapped,
		bool	detailtex = false
	)

Definition at line 506 of file ani_texture.cpp.

References active, alltrim(), anis, curtime, DEFAULT_ADDRESS_MODE, VSFileSystem::VSFile::Eof(), accountXML::file, VSFileSystem::VSFile::Fscanf(), g_game, VSRandom::genrand_int32(), VSFileSystem::VSFile::GetFilename(), VSFileSystem::VSFile::GetType(), GFXFALSE, GFXTRUE, i, j, Texture::maxtcoord, Texture::mintcoord, numframes, VSFileSystem::Ok, Texture::original, XMLSupport::parse_float(), XMLSupport::parse_option_ispresent(), XMLSupport::parse_option_value(), parseAddressMode(), VSFileSystem::VSFile::ReadLine(), Reset(), SetInterpolateFrames(), SetInterpolateTCoord(), SetLoop(), SetLoopInterp(), setTime(), Texture::stage, Texture::Texture(), TEXTURE2D, TEXTURE_2D, timeperframe, game_data_t::use_animations, game_data_t::use_textures, game_data_t::use_videos, Vector, and vsrandom.

Referenced by Load().

{
    char options[1024];
    f.Fscanf( "%d %f", &numframes, &timeperframe );
    f.ReadLine( options, sizeof (options)-sizeof (*options) );
    options[sizeof (options)/sizeof (*options)-1] = 0;
    alltrim( options );

    Reset();

    vidMode = XMLSupport::parse_option_ispresent( options, "video" );
    SetInterpolateFrames( XMLSupport::parse_option_ispresent( options, "interpolateFrames" ) );
    SetInterpolateTCoord( XMLSupport::parse_option_ispresent( options, "interpolateTCoord" ) );
    if ( XMLSupport::parse_option_ispresent( options, "forceLoopInterp" ) )
        SetLoopInterp( true );

    else if ( XMLSupport::parse_option_ispresent( options, "forceNoLoopInterp" ) )
        SetLoopInterp( false );
    if ( XMLSupport::parse_option_ispresent( options, "forceLoop" ) )
        SetLoop( true );

    else if ( XMLSupport::parse_option_ispresent( options, "forceNoLoop" ) )
        SetLoop( false );
    if ( XMLSupport::parse_option_ispresent( options, "startRandom" ) ) {
        int curf = vsrandom.genrand_int32()%numframes;
        setTime( (0.00001+curf)*timeperframe );
    }
    string addrmodestr = XMLSupport::parse_option_value( options, "addressMode", "" );
    defaultAddressMode = parseAddressMode( addrmodestr, DEFAULT_ADDRESS_MODE );

    string defms = XMLSupport::parse_option_value( options, "mins", "0" );
    string defmt = XMLSupport::parse_option_value( options, "mint", "0" );
    string defmr = XMLSupport::parse_option_value( options, "minr", "0" );
    string defMs = XMLSupport::parse_option_value( options, "maxs", "1" );
    string defMt = XMLSupport::parse_option_value( options, "maxt", "1" );
    string defMr = XMLSupport::parse_option_value( options, "maxr", "1" );

    int    midframe; //FIXME midframe not initialized by all paths below
    midframe = 0; //FIXME this line temporarily added by chuck_starchaser
    bool   loadall;
    if (!vidMode)
        loadall = !( g_game.use_animations == 0 || (g_game.use_animations != 0 && g_game.use_textures == 0) );

    else
        loadall = !( g_game.use_videos == 0 || (g_game.use_videos != 0 && g_game.use_textures == 0) );
    if (!loadall) {
        timeperframe *= numframes;
        midframe      = numframes/2;
        numframes     = 1;
    }                                                                                     //Added by Klauss

    active = 0;
    int  nf = (vidMode ? 1 : numframes);
    Decal  = new Texture*[nf];
    if (vidMode) Decal[0] = new Texture;
    char temp[512] = "white.bmp";
    char file[512] = "white.bmp";
    char alp[512]  = "white.bmp";
    char opt[512]  = "";
    int i = 0, j = 0;
    for (; i < static_cast<int>(numframes); i++)
        if ( loadall || (i == midframe) ) { //FIXME midframe used without guaranteed initialization
            //if() added by Klauss
            int numgets = 0;
            while ( numgets <= 0 && !f.Eof() ) {
                if (f.ReadLine( temp, 511 ) == Ok) {
                    temp[511] = '\0';
                    file[0]   = 'z';
                    file[1]   = '\0';
                    alp[0]    = 'z';
                    alp[1]    = '\0';                            //windows crashes on null
                    opt[0]    = 'z';
                    opt[1]    = '\0';

                    numgets   = sscanf( temp, "%s %s %[^\r\n]", file, alp, opt );
                    if ( (numgets < 2) || (strcmp( alp, "-" ) == 0) ) alp[0] = '\0';
                    alltrim( opt );
                } else {break; }}
            if (vidMode) {
                frames.push_back( StringPool::Reference( string( temp ) ) );
                frames_mintc.push_back( Vector(
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "mins", defms ) ),
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "mint", defmt ) ),
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "minr", defmr ) ) ) );
                frames_maxtc.push_back( Vector(
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxs", defMs ) ),
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxt", defMt ) ),
                                           XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxr", defMr ) ) ) );
            } else {
                enum ADDRESSMODE addrmode = parseAddressMode( XMLSupport::parse_option_value( opt,
                                                                                              "addressMode",
                                                                                              "" ), defaultAddressMode );
                if (alp[0] != '\0') {
                    Decal[j++] =
                        new Texture( file,
                                     alp,
                                     stage,
                                     ismipmapped,
                                     TEXTURE2D,
                                     TEXTURE_2D,
                                     1,
                                     0,
                                     (g_game.use_animations) ? GFXTRUE : GFXFALSE,
                                     65536,
                                     (detailtex ? GFXTRUE : GFXFALSE),
                                     GFXFALSE,
                                     addrmode );
                } else {
                    Decal[j++] = new Texture( file,
                                              stage,
                                              ismipmapped,
                                              TEXTURE2D,
                                              TEXTURE_2D,
                                              (g_game.use_animations) ? GFXTRUE : GFXFALSE,
                                              65536,
                                              (detailtex ? GFXTRUE : GFXFALSE),
                                              GFXFALSE,
                                              addrmode );
                }
                if (Decal[j-1]) {
                    Decal[j-1]->mintcoord = Vector(
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "mins", defms ) ),
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "mint", defmt ) ),
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "minr", defmr ) ) );
                    Decal[j-1]->maxtcoord = Vector(
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxs", defMs ) ),
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxt", defMt ) ),
                        XMLSupport::parse_float( XMLSupport::parse_option_value( opt, "maxr", defMr ) ) );
                }
            }
        }
    this->texstage    = stage;
    this->detailTex   = detailtex;
    this->ismipmapped = ismipmapped;
    if (vidMode) {
        wrapper_file_path = f.GetFilename();
        wrapper_file_type = f.GetType();
    }
    original    = NULL;
    loadSuccess = true;

    anis.insert( this );

    //Needed - must do housekeeping, tcoord stuff and the like.
    setTime( curtime );
}

void AnimatedTexture::LoadFrame ( int  num)

virtual

Definition at line 653 of file ani_texture.cpp.

References BILINEAR, VSFileSystem::VSFile::Close(), gl_options_t::compression, f, accountXML::file, g_game, GFXFALSE, GFXTRUE, gl_options, MIPMAP, NEAREST, numframes, VSFileSystem::Ok, VSFileSystem::VSFile::OpenReadOnly(), Texture::original, XMLSupport::parse_option_value(), parseAddressMode(), TEXTURE2D, TEXTURE_2D, TRILINEAR, and game_data_t::use_videos.

Referenced by MakeActive().

{
    if ( !vidMode || (Decal == NULL) || (*Decal == NULL) ) return;
    if ( (frame < 0) || (frame >= static_cast<int>(numframes)) ) return;
    if ( (activebound >= 0) && (activebound < numframes) && (frames[frame] == frames[activebound]) ) return;
    const char *temp   = frames[frame].get().c_str();
    char   file[512]   = "white.bmp";
    char   alp[512]    = "white.bmp";
    char   opt[512]    = "";
    int    numgets     = 0;
    numgets = sscanf( temp, "%s %s %[^\r\n]", file, alp, opt );
    if ( (numgets < 2) || (strcmp( alp, "-" ) == 0) ) alp[0] = '\0';
    string addrmodestr = XMLSupport::parse_option_value( opt, "addressMode", "" );
    enum ADDRESSMODE addrmode = parseAddressMode( addrmodestr, defaultAddressMode );

    //Override compression options temporarily
    //NOTE: This is ugly, but otherwise we would have to hack Texture way too much,
    //or double the code. Let's use this then.
    int ocompression = gl_options.compression;
    gl_options.compression = 0;

    //Without this, VSFileSystem won't find the file -- ugly, but it's how it is.
    VSFile f;
    VSError     err    = f.OpenReadOnly( wrapper_file_path, wrapper_file_type );

    //Override mipmaping for video mode - too much overhead in generating the mipmamps.
    enum FILTER ismip2 =
        ( (ismipmapped == BILINEAR) || (ismipmapped == TRILINEAR) || (ismipmapped == MIPMAP) ) ? BILINEAR : NEAREST;
    loadSuccess = true;
    if (alp[0] != '\0') {
        (*Decal)->Load( file,
                        alp,
                        texstage,
                        ismip2,
                        TEXTURE2D,
                        TEXTURE_2D,
                        1,
                        0,
                        (g_game.use_videos) ? GFXTRUE : GFXFALSE,
                        65536,
                        (detailTex ? GFXTRUE : GFXFALSE),
                        GFXTRUE,
                        addrmode );
    } else if (numgets == 1) {
        (*Decal)->Load( file, texstage, ismip2, TEXTURE2D, TEXTURE_2D, (g_game.use_videos) ? GFXTRUE : GFXFALSE, 65536,
                        (detailTex ? GFXTRUE : GFXFALSE), GFXTRUE, addrmode );
    } else {
        loadSuccess = false;
    }
    if (err <= Ok) f.Close();
    gl_options.compression = ocompression;

    original    = NULL;
    loadSuccess = loadSuccess && (*Decal)->LoadSuccess();
    if (loadSuccess) activebound = frame;
}

bool AnimatedTexture::LoadSuccess ( )

virtual

If the texture has loaded properly returns true.

Reimplemented from Texture.

Definition at line 710 of file ani_texture.cpp.

{
    return loadSuccess != false;
}

void AnimatedTexture::LoadVideoSource

(

VSFileSystem::VSFile &

f)

Definition at line 436 of file ani_texture.cpp.

References anis, BILINEAR, Texture::Bind(), VSFileSystem::VSFile::Close(), Texture::data, e, VidFile::getDuration(), VSFileSystem::VSFile::GetFilename(), VidFile::getFrameBuffer(), VidFile::getFrameRate(), VidFile::getHeight(), VSFileSystem::VSFile::GetType(), VidFile::getWidth(), GFXFALSE, gl_options, Texture::image_target, int, gl_options_t::max_movie_dimension, Texture::maxtcoord, Texture::mintcoord, NEAREST, numframes, VidFile::open(), gl_options_t::pot_video_textures, gl_options_t::rect_textures, Reset(), TEXTURE_RECTANGLE, Texture::texture_target, TEXTURERECT, and timeperframe.

Referenced by Clone(), CreateVideoTexture(), and Load().

{
    wrapper_file_path = f.GetFilename();
    wrapper_file_type = f.GetType();
    f.Close();

    Reset();

    vidMode = true;

    try {
        vidSource     = new::VidFile();
        vidSource->open( wrapper_file_path, gl_options.max_movie_dimension, gl_options.pot_video_textures );

        physicsactive = vidSource->getDuration();
        timeperframe  = 1.0/vidSource->getFrameRate();
        numframes     = (unsigned int) (physicsactive*timeperframe);

        loadSuccess   = true;
    }
    catch (::VidFile::Exception e) {
        loadSuccess = false;
    }
    if (loadSuccess) {
        sizeX = vidSource->getWidth();
        sizeY = vidSource->getHeight();
        mode  = _24BIT;
        data  = (unsigned char*) vidSource->getFrameBuffer();
        if ((ismipmapped == BILINEAR || ismipmapped == NEAREST) && gl_options.rect_textures) {
            texture_target = TEXTURERECT;
            image_target = TEXTURE_RECTANGLE;
        }
        
        Bind( 65535, GFXFALSE );

        maxtcoord.x = sizeX-0.5f;
        maxtcoord.y = sizeY-0.5f;
        mintcoord.x = 0.5f;
        mintcoord.y = 0.5f;
        
        if (image_target != TEXTURE_RECTANGLE) {
            maxtcoord.x /= sizeX;
            maxtcoord.y /= sizeY;
            mintcoord.x /= sizeX;
            mintcoord.y /= sizeY;
        }
        
        anis.insert( this );
    }
}

virtual void AnimatedTexture::MakeActive ( )

inlinevirtual

Binds the texture in the GFX library.

Reimplemented from Texture.

Definition at line 118 of file ani_texture.h.

Referenced by Animation::DrawAsVSSprite(), DrawDamageFlash(), Animation::DrawNoTransform(), Animation::DrawNow(), and MakeActive().

    {
        MakeActive( texstage, 0 );
    }                                                   //MSVC bug seems to hide MakeActive() if we define MakeActive(int,int) - the suckers!

virtual void AnimatedTexture::MakeActive ( int  stage)

inlinevirtual

Reimplemented from Texture.

Definition at line 123 of file ani_texture.h.

References MakeActive().

    {
        MakeActive( stage, 0 );
    }                                                         //MSVC bug seems to hide MakeActive(int) if we define MakeActive(int,int) - the suckers!

void AnimatedTexture::MakeActive ( int  stage, int  pass  )

virtual

Reimplemented from Texture.

Definition at line 54 of file ani_texture.cpp.

References ActivateWhite(), active, active_fraction, GFXColor::b, gl_options_t::compression, curtime, done, e, GFXColor::g, GetInterpolateFrames(), GetInterpolateTCoord(), GetLoop(), GetLoopInterp(), GFXColorf(), GFXFALSE, GFXINTERPOLATETEXTURE, GFXTextureEnv(), gl_options, int, intmax(), intmin(), LoadFrame(), MakeActive(), Texture::MakeActive(), Texture::maxtcoord, Texture::mintcoord, gl_options_t::Multitexture, nextactive, numframes, numFrames(), GFXColor::r, VidFile::seek(), setTime(), timeperframe, Texture::Transfer(), VSFileSystem::vs_dprintf(), and VidFile::Exception::what().

{
    // Set active frame and texture coordinates
    if (timeperframe && !vidSource) {
        unsigned int numframes = numFrames();
        unsigned int active    = ( (unsigned int) (curtime/timeperframe) );
        if ( GetLoop() )
            active %= numframes;

        else
            active = intmin( active, numframes-1 );
        unsigned int nextactive = ( GetLoopInterp() ? ( (active+1)%numframes ) : intmin( active+1, numframes-1 ) );
        float fraction = (curtime/timeperframe)-(unsigned int) (curtime/timeperframe);
        if (fraction < 0) fraction += 1.0f;
        this->active     = active;
        this->nextactive = nextactive;
        this->active_fraction = fraction;
        if (!vidMode) {
            if ( GetInterpolateTCoord() && (active != nextactive) ) {
                if (Decal && Decal[active] && Decal[nextactive]) {
                    this->maxtcoord = (1-fraction)*Decal[active]->maxtcoord+fraction*Decal[nextactive]->maxtcoord;
                    this->mintcoord = (1-fraction)*Decal[active]->mintcoord+fraction*Decal[nextactive]->mintcoord;
                }
            } else if (Decal && Decal[active]) {
                this->maxtcoord = Decal[active]->maxtcoord;
                this->mintcoord = Decal[active]->mintcoord;
            }
        } else {
            if ( GetInterpolateTCoord() && (active != nextactive) ) {
                if ( frames_maxtc.size() < intmax( active, nextactive ) ) {
                    this->maxtcoord = (1-fraction)*frames_maxtc[active]+fraction*frames_maxtc[nextactive];
                    this->mintcoord = (1-fraction)*frames_mintc[active]+fraction*frames_mintc[nextactive];
                }
            } else if ( active < frames_maxtc.size() ) {
                this->maxtcoord = frames_maxtc[active];
                this->mintcoord = frames_mintc[active];
            }
        }
        active = ( (unsigned int) (curtime/timeperframe) )%numframes;
    }
    
    // Effectively activate texture units
    switch (pass)
    {
    case 0:
        if (!vidMode) {
            if ( GetInterpolateFrames() && (active != nextactive) ) {
                if ( gl_options.Multitexture && ( (stage+1) < static_cast<int>(gl_options.Multitexture) ) ) {
                    if (Decal && Decal[nextactive%numframes])
                        Decal[nextactive%numframes]->MakeActive( stage+1 );

                    else
                        ActivateWhite( stage+1 );
                    GFXTextureEnv( stage+1, GFXINTERPOLATETEXTURE, active_fraction );
                    if (Decal && Decal[active%numframes])
                        Decal[active%numframes]->MakeActive( stage );

                    else
                        ActivateWhite( stage );
                    //GFXTextureEnv(stage,GFXMODULATETEXTURE);
                } else {
                    if (Decal && Decal[active%numframes])
                        Decal[active%numframes]->MakeActive( stage );

                    else
                        ActivateWhite( stage );
                    multipass_interp_basecolor = GFXColorf();
                    GFXColor color = multipass_interp_basecolor;
                    color.r *= (1.0-active_fraction);
                    color.g *= (1.0-active_fraction);
                    color.b *= (1.0-active_fraction);
                    GFXColorf( color );
                    //GFXTextureEnv(stage,GFXMODULATETEXTURE);
                }
            } else {
                if (Decal && Decal[active%numframes])
                    Decal[active%numframes]->MakeActive( stage );

                else
                    ActivateWhite( stage );
            }
        } else if (!vidSource) {
            //No frame interpolation anything supported
            if (Decal && *Decal) {
                if (active != activebound)
                    LoadFrame( active%numframes );
                (*Decal)->MakeActive( stage );
            }
        } else {
            try {
                //vidSource leaves frame data in its framebuffer, and our image data is initialized
                //to point to that framebuffer, so all we need to do is transfer it to the GL.
                if ( vidSource->seek( curtime ) ) {
                    //Override compression options temporarily
                    //NOTE: This is ugly, but otherwise we would have to hack Texture way too much,
                    //or double the code. Let's use this then.
                    int ocompression = gl_options.compression;
                    gl_options.compression = 0;
                    
                    VSFileSystem::vs_dprintf( 1, "Transferring video frame\n" );
                    Transfer( 65535, GFXFALSE );
                    
                    gl_options.compression = ocompression;
                }
            }
            catch (::VidFile::EndOfStreamException e) {
                if (GetLoop() && curtime > 0) {
                    setTime( 0 );
                    MakeActive( stage, pass );
                    return;
                } else {
                    done = true;
                }
            }
            catch (::VidFile::Exception e) {
                VSFileSystem::vs_dprintf( 1, "\nVidFile exception: %s\n", e.what() );
            }
            Texture::MakeActive( stage, pass );
        }
        break;
    case 1:
        if ( !vidMode && GetInterpolateFrames() && (active != nextactive)
            && !( gl_options.Multitexture && ( (stage+1) < static_cast<int>(gl_options.Multitexture) ) ) ) {
            if (Decal && Decal[nextactive%numframes])
                Decal[nextactive%numframes]->MakeActive( stage );

            else
                ActivateWhite( stage );
            GFXColor color = multipass_interp_basecolor;
            color.r *= active_fraction;
            color.g *= active_fraction;
            color.b *= active_fraction;
            GFXColorf( color );
            //GFXTextureEnv(stage,GFXMODULATETEXTURE);
        } else {ActivateWhite( stage ); } break;
    }
}

virtual unsigned int AnimatedTexture::numFrames ( ) const

inlinevirtual

Reimplemented from Texture.

Definition at line 76 of file ani_texture.h.

References numframes.

Referenced by MakeActive(), and SpriteStarVlist::SpriteStarVlist().

    {
        return numframes;
    }

unsigned int AnimatedTexture::numLayers ( ) const

virtual

Reimplemented from Texture.

Definition at line 715 of file ani_texture.cpp.

References active, GetInterpolateFrames(), gl_options, gl_options_t::Multitexture, and nextactive.

Referenced by Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), and Animation::DrawNow().

{
    if ( GetInterpolateFrames() && (active != nextactive) && gl_options.Multitexture
        && ( (texstage+1) < static_cast<int>(gl_options.Multitexture) ) )
        return 2;

    else
        return 1;
}

unsigned int AnimatedTexture::numPasses ( ) const

virtual

Reimplemented from Texture.

Definition at line 725 of file ani_texture.cpp.

References active, GetInterpolateFrames(), gl_options, gl_options_t::Multitexture, and nextactive.

Referenced by Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), and Animation::DrawNow().

{
    if ( GetInterpolateFrames() && (active != nextactive) ) {
        if ( gl_options.Multitexture && ( (texstage+1) < static_cast<int>(gl_options.Multitexture) ) )
            return 1;
        else
            return 2;
    } else {
        return 1;
    }
}

const Texture * AnimatedTexture::Original ( ) const

virtual

Reimplemented from Texture.

Definition at line 339 of file ani_texture.cpp.

References active, and Texture::Original().

{
    return Decal ? Decal[active]->Original() : this;
}

Texture * AnimatedTexture::Original ( )

virtual

Reimplemented from Texture.

Definition at line 334 of file ani_texture.cpp.

References active, and Texture::Original().

{
    return Decal ? Decal[active]->Original() : this;
}

void AnimatedTexture::Reset

(

)

Definition at line 399 of file ani_texture.cpp.

References active, curtime, done, numframes, and timeperframe.

Referenced by LoadAni(), LoadVideoSource(), and VDU::SetCommAnimation().

{
    curtime = 0;
    active = 0;
    activebound   = -1;
    img_sides     = SIDE_SINGLE;
    physicsactive = numframes*timeperframe;
    done          = false;
}

void AnimatedTexture::SetInterpolateFrames ( bool  set)

inline

Definition at line 137 of file ani_texture.h.

Referenced by LoadAni().

    {
        options = (options&~optInterpolateFrames)|(set ? optInterpolateFrames : 0);
    }

void AnimatedTexture::SetInterpolateTCoord ( bool  set)

inline

Definition at line 142 of file ani_texture.h.

Referenced by LoadAni().

    {
        options = (options&~optInterpolateTCoord)|(set ? optInterpolateTCoord : 0);
    }

void AnimatedTexture::SetLoop ( bool  set)

inline

Definition at line 152 of file ani_texture.h.

Referenced by Animation::Animation(), CreateVideoTexture(), and LoadAni().

    {
        options = (options&~optLoop)|(set ? optLoop : 0);
    }

void AnimatedTexture::SetLoopInterp ( bool  set)

inline

Definition at line 147 of file ani_texture.h.

Referenced by Animation::Animation(), and LoadAni().

    {
        options = (options&~optLoopInterp)|(set ? optLoopInterp : 0);
    }

void AnimatedTexture::setTime ( double  tim)

virtual

Reimplemented from Texture.

Definition at line 258 of file ani_texture.cpp.

References curtime.

Referenced by LoadAni(), MakeActive(), SpriteStarVlist::SpriteStarVlist(), and UpdateAllFrame().

{
    curtime = tim;
}

void AnimatedTexture::SetTimeSource

(

SharedPtr< Audio::Source >

source)

Definition at line 737 of file ani_texture.cpp.

{
    timeSource = source;
    if (source)
        options |= optSoundTiming;

    else
        options &= ~optSoundTiming;
}

bool AnimatedTexture::SetupPass ( int  pass, int  stage, const enum BLENDFUNC  src, const enum BLENDFUNC  dst  )

virtual

Reimplemented from Texture.

Definition at line 192 of file ani_texture.cpp.

References GetInterpolateFrames(), GFXADDTEXTURE, GFXColorf(), GFXTextureEnv(), gl_options, and gl_options_t::Multitexture.

Referenced by Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), Animation::DrawNow(), and SetupPass().

{
    switch (pass)
    {
    case -1:
        if ( !vidMode && GetInterpolateFrames() ) {
            if ( !( gl_options.Multitexture && ( (stage+1) < static_cast<int>(gl_options.Multitexture) ) ) )
                GFXColorf( multipass_interp_basecolor );                  //Restore old color
            else
                //GFXTextureEnv(texstage,GFXMODULATETEXTURE); //Most expect this
                GFXTextureEnv( stage+1, GFXADDTEXTURE );                  //Most expect this
        }
        return true;

    default:
        //Hey! Nothing to do! Yippie!
        return true;
    }
}

bool AnimatedTexture::SetupPass ( int  pass, const enum BLENDFUNC  src, const enum BLENDFUNC  dst  )

inlinevirtual

Reimplemented from Texture.

Definition at line 132 of file ani_texture.h.

References SetupPass().

    {
        return SetupPass( pass, texstage, src, dst );
    }

void AnimatedTexture::UpdateAllFrame ( )

static

Definition at line 218 of file ani_texture.cpp.

References anis, curTime(), GetElapsedTime(), GetTimeSource(), lastcurtime, lastrealtime, realTime(), and setTime().

Referenced by bootstrap_draw(), GameStarSystem::Draw(), BaseInterface::Draw(), and Briefing::Render().

{
    double elapsed = GetElapsedTime();
    double realtime = realTime();
    for (set< AnimatedTexture* >::iterator iter = anis.begin(); iter != anis.end(); iter++) {
        AnimatedTexture *ani = *iter;
        if (ani->options & optSoundTiming) {
            // lazy init
            if (ani->lastrealtime == 0)
                ani->lastrealtime = realtime;
            
            // de-jitter, playtime reporting tends to have some jitter
            double newcurtime = ani->GetTimeSource()->getPlayingTime();
            double delta = realtime - ani->lastrealtime;
            double drift = newcurtime - ani->lastcurtime - delta;
            if (fabs(drift) > 1.0) {
                ani->lastcurtime = newcurtime - delta;
                ani->lastrealtime = realtime;
            } else if (fabs(drift) > 0.2) {
                double catchup = drift * ((delta > 0.5) ? 0.5 : delta);
                ani->lastcurtime += catchup;
                ani->lastrealtime = realtime;
            }
            ani->setTime(ani->lastcurtime + delta);
        } else {
            ani->setTime( ani->curTime()+elapsed );
        }
    }
}

void AnimatedTexture::UpdateAllPhysics ( )

static

Definition at line 212 of file ani_texture.cpp.

References anis, and SIMULATION_ATOM.

Referenced by UpdateAnimatedTexture().

{
    for (set< AnimatedTexture* >::iterator iter = anis.begin(); iter != anis.end(); iter++)
        (*iter)->physicsactive -= SIMULATION_ATOM;
}

Member Data Documentation

unsigned int AnimatedTexture::active

protected

Definition at line 56 of file ani_texture.h.

Referenced by LoadAni(), MakeActive(), numLayers(), numPasses(), Original(), Reset(), and ~AnimatedTexture().

float AnimatedTexture::active_fraction

protected

Definition at line 58 of file ani_texture.h.

Referenced by MakeActive().

bool AnimatedTexture::constframerate

protected

Definition at line 65 of file ani_texture.h.

Referenced by constFrameRate().

double AnimatedTexture::curtime

protected

Definition at line 59 of file ani_texture.h.

Referenced by curTime(), Done(), Load(), LoadAni(), MakeActive(), Reset(), and setTime().

bool AnimatedTexture::done

protected

Definition at line 66 of file ani_texture.h.

Referenced by Done(), MakeActive(), and Reset().

double AnimatedTexture::lastcurtime

protected

Definition at line 62 of file ani_texture.h.

Referenced by UpdateAllFrame().

double AnimatedTexture::lastrealtime

protected

Definition at line 63 of file ani_texture.h.

Referenced by UpdateAllFrame().

unsigned int AnimatedTexture::nextactive

protected

Definition at line 57 of file ani_texture.h.

Referenced by MakeActive(), numLayers(), and numPasses().

unsigned int AnimatedTexture::numframes

protected

Definition at line 54 of file ani_texture.h.

Referenced by Clone(), Destroy(), Done(), LoadAni(), LoadFrame(), LoadVideoSource(), MakeActive(), numFrames(), and Reset().

float AnimatedTexture::timeperframe

protected

Definition at line 55 of file ani_texture.h.

Referenced by Done(), framesPerSecond(), LoadAni(), LoadVideoSource(), MakeActive(), and Reset().

---

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

• src/gfx/ani_texture.h
• src/gfx/ani_texture.cpp