KSG-Framework/Animation.cpp

#include "Animation.h"
#include "Bild.h"
#include "DateiSystem.h"
#include "Text.h"
#include "InitDatei.h"
#include "ToolTip.h"
#include "Rahmen.h"

using namespace Framework;

// Inhalt der Animation2DData Klasse aus Animation.h
// Konstruktor
Animation2DData::Animation2DData()
	: bilder( 0 ),
	  bildAnzahl( 0 ),
	  fps( 0 ),
	  wiederhohlen( 0 ),
	  transparent( 0 ),
	  ref( 1 )
{
	InitializeCriticalSection( &cs );
}

// Destruktor
Animation2DData::~Animation2DData()
{
	reset();
	DeleteCriticalSection( &cs );
}

// nicht constant
void Animation2DData::lock()
{
	EnterCriticalSection( &cs );
}

void Animation2DData::unlock()
{
	LeaveCriticalSection( &cs );
}

void Animation2DData::ladeAnimation( InitDatei *datei )
{
	if( !datei )
		return;
	reset();
	int anz = datei->getWertAnzahl();
	lock();
	if( datei->wertExistiert( "fps" ) )
	{
		--anz;
		fps = TextZuInt( datei->zWert( "fps" )->getText(), 10 );
	}
	if( datei->wertExistiert( "wiederhohlen" ) )
	{
		--anz;
		wiederhohlen = datei->zWert( "wiederhohlen" )->istGleich( "true" );
	}
	if( datei->wertExistiert( "transparent" ) )
	{
		--anz;
		transparent = datei->zWert( "transparent" )->istGleich( "true" );
	}
	Bild **bilder = new Bild*[ anz ];
	int j = 0;
	for( int i = 0; i < anz; ++i )
	{
		if( datei->zName( i )->istGleich( "fps" ) || 
			datei->zName( i )->istGleich( "wiederhohlen" ) || 
			datei->zName( i )->istGleich( "transparent" ) )
			continue;
		bilder[ j ] = 0;
		Text pfad = datei->zWert( i )->getText();
		if( pfad.hat( ".ltdb/" ) && pfad.getLänge() > 7 )
		{
			Text *name = pfad.getTeilText( pfad.positionVon( ".ltdb/", pfad.anzahlVon( ".ltdb/" ) - 1 ) + 6 );
			pfad.setText( pfad.getTeilText( 0, pfad.getLänge() - name->getLänge() - 1 ) );
			LTDBDatei *dat = new LTDBDatei();
			dat->setDatei( pfad.getThis() );
			dat->leseDaten( 0 );
			bilder[ j ] = dat->laden( 0, name );
			dat->release();
		}
		++j;
	}
	this->bilder = new Bild*[ bildAnzahl ];
	j = 0;
	for( int i = 0; i < anz; ++i )
	{
		if( !bilder[ i ] )
			++j;
		else
			this->bilder[ i - j ] = bilder[ i ];
	}
	delete[] bilder;
	unlock();
	datei->release();
}

void Animation2DData::ladeAnimation( LTDBDatei *datei )
{
	if( !datei )
		return;
	reset();
	datei->leseDaten( 0 );
	int anz = datei->getBildAnzahl();
	RCArray< Text > *list = datei->zBildListe();
	lock();
	Bild **bilder = new Bild*[ anz ];
	for( int i = 0; i < anz; ++i )
	{
		bilder[ i ] = datei->laden( 0, list->get( i ) );
		if( bilder[ i ] )
			++bildAnzahl;
	}
	this->bilder = new Bild*[ bildAnzahl ];
	int j = 0;
	for( int i = 0; i < anz; ++i )
	{
		if( !bilder[ i ] )
			++j;
		else
			this->bilder[ i - j ] = bilder[ i ];
	}
	delete[] bilder;
	unlock();
	datei->release();
}

void Animation2DData::setFPS( int fps )
{
	this->fps = fps;
}

void Animation2DData::setWiederhohlend( bool wh )
{
	wiederhohlen = wh;
}

void Animation2DData::setTransparent( bool trp )
{
	transparent = trp;
}

void Animation2DData::reset()
{
	lock();
	for( int i = 0; i < bildAnzahl; ++i )
		bilder[ i ] = bilder[ i ]->release();
	delete[] bilder;
	bilder = 0;
	bildAnzahl = 0;
	fps = 30;
	wiederhohlen = 0;
	transparent = 0;
	unlock();
}

// constant
Bild *Animation2DData::getBild( int i ) const
{
	return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ]->getThis() : 0;
}

Bild *Animation2DData::zBild( int i ) const
{
	return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ] : 0;
}

int Animation2DData::getBildAnzahl() const
{
	return bildAnzahl;
}

int Animation2DData::getFPS() const
{
	return fps;
}

bool Animation2DData::istWiederhohlend() const
{
	return wiederhohlen;
}

bool Animation2DData::istTransparent() const
{
	return transparent;
}

// Reference Counting
Animation2DData *Animation2DData::getThis()
{
	++ref;
	return this;
}

Animation2DData *Animation2DData::release()
{
	--ref;
	if( !ref )
		delete this;
	return 0;
}

// Inhalt der Animation2D Klasse aus Animation.h
// Konstruktor
Animation2D::Animation2D()
	: Zeichnung(),
	data( 0 ),
	jetzt( 0 ),
	ausgleich( 0 ),
	alpha( 0 ),
	maxAlpha( 255 ),
	rahmen( 0 ),
	ram( 0 ),
	aps( 255 * 60 ),
	sichtbar( 0 ),
	ref( 1 )
{
}

// Destruktor
Animation2D::~Animation2D()
{
	if( data )
		data->release();
	if( ram )
		ram->release();
}

// nicht constant
void Animation2D::setRahmen( bool ram )
{
	rahmen = ram;
}

void Animation2D::setRahmenZ( LRahmen *ram )
{
	if( this->ram )
		this->ram->release();
	this->ram = ram;
}

void Animation2D::setRahmenBreite( int br )
{
	if( !ram )
		ram = new LRahmen();
	ram->setRamenBreite( br );
}

void Animation2D::setRahmenFarbe( int f )
{
	if( !ram )
		ram = new LRahmen();
	ram->setFarbe( f );
}

void Animation2D::setAnimationDataZ( Animation2DData *data )
{
	lockZeichnung();
	if( this->data )
		this->data->release();
	this->data = data;
	if( alpha )
		rend = 1;
	unlockZeichnung();
}

void Animation2D::setAlphaMaske( unsigned char alpha )
{
	maxAlpha = alpha;
}

void Animation2D::setAPS( int aps )
{
	this->aps = aps;
}

void Animation2D::setSichtbar( bool sichtbar )
{
	this->sichtbar = sichtbar;
}

bool Animation2D::tick( double zeit )
{
	lockZeichnung();
	if( !data || ( !alpha && !sichtbar ) )
	{
		bool ret = rend;
		rend = 0;
		unlockZeichnung();
		return ret;
	}
	if( sichtbar && alpha < maxAlpha )
	{
		if( alpha + aps * zeit >= maxAlpha )
			alpha = maxAlpha;
		else
			alpha += (unsigned char)(aps * zeit);
		rend = 1;
	}
	else if( !sichtbar && alpha > 0 )
	{
		if( alpha - aps * zeit <= 0 )
			alpha = 0;
		else
			alpha -= (unsigned char)(aps * zeit);
		rend = 1;
	}
	ausgleich += zeit;
	int tmp = jetzt;
	data->lock();
	if( ausgleich >= 1.0 / data->getFPS() )
	{
		ausgleich -= 1.0 / data->getFPS();
		++jetzt;
		if( jetzt >= data->getBildAnzahl() )
		{
			if( data->istWiederhohlend() )
				jetzt = 0;
			else
				jetzt = data->getBildAnzahl();
		}
	}
	data->unlock();
	if( tmp != jetzt )
		rend = 1;
	bool ret = rend;
	rend = 0;
	unlockZeichnung();
	return ret;
}

void Animation2D::render( Bild &zRObj )
{
	lockZeichnung();
	if( !data )
	{
		unlockZeichnung();
		return;
	}
    __super::render( zRObj );
	data->lock();
	if( data->zBild( jetzt ) )
	{
		zRObj.setAlpha( alpha );
		if( data->istTransparent() )
			zRObj.alphaBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
		else
			zRObj.drawBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
		if( ram && rahmen )
		{
			ram->setPosition( pos );
			ram->setGröße( gr );
			ram->render( zRObj );
		}
		zRObj.releaseAlpha();
	}
	data->unlock();
	unlockZeichnung();
}

// constant
Animation2DData *Animation2D::getAnimationData() const
{
	return data ? data->getThis() : 0;
}

Animation2DData *Animation2D::zAnimationData() const
{
	return data;
}

bool Animation2D::istSichtbar() const
{
	return sichtbar;
}

int Animation2D::getJetzt() const
{
	return jetzt;
}

unsigned char Animation2D::getAlphaMaske() const
{
	return maxAlpha;
}

bool Animation2D::hatRahmen() const
{
	return rahmen;
}

LRahmen *Animation2D::getRahmen() const
{
	return ram ? ram->getThis() : 0;
}

LRahmen *Animation2D::zRahmen() const
{
	return ram;
}

int Animation2D::getRahmenBreite() const
{
	return ram ? ram->getRBreite() : 0;
}

int Animation2D::getRahmenFarbe() const
{
	return ram ? ram->getFarbe() : 0;
}

Zeichnung *Animation2D::dublizieren() const
{
	Animation2D *ret = new Animation2D();
	ret->setPosition( pos );
	ret->setGröße( gr );
	ret->setMausEreignisParameter( makParam );
	ret->setTastaturEreignisParameter( takParam );
	ret->setMausEreignis( Mak );
	ret->setTastaturEreignis( Tak );
	if( toolTip )
		ret->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
	if( data )
		ret->setAnimationDataZ( data->getThis() );
	ret->setAPS( aps );
	ret->setSichtbar( sichtbar );
	ret->setAlphaMaske( maxAlpha );
	ret->setRahmen( rahmen );
	if( ram )
	{
		ret->setRahmenBreite( ram->getRBreite() );
		ret->setRahmenFarbe( ram->getFarbe() );
	}
	return ret;
}

// Reference Counting
Animation2D *Animation2D::getThis()
{
	++ref;
	return this;
}

Animation2D *Animation2D::release()
{
	--ref;
	if( !ref )
		delete this;
	return 0;
}