2DCreator/2DCreator/Data.cpp

#include "Data.h"

// Inhalt der VertexData Klasse aus Data.h
// Konstruktor
VertexData::VertexData( Vec2< float > v, Punkt t )
{
	vertex = v;
	textur = t;
	selected = 0;
	sichtbar = 1;
	ref = 1;
}

// nicht constant
void VertexData::nachLinks( float num )
{
	if( selected )
		vertex.x -= num;
}

void VertexData::nachOben( float num )
{
	if( selected )
		vertex.y -= num;
}

void VertexData::saveTextur( Punkt tPos )
{
	textur = (Punkt)vertex - tPos;
}

void VertexData::select( Punkt p1, Punkt p2 )
{
	selected |= vertex.istInRegion( p1, p2 ) && sichtbar;
}

void VertexData::deSelect()
{
	selected = 0;
}

void VertexData::setAuswahl( bool ausw )
{
	selected = ausw;
}

void VertexData::setSichtbar( bool s )
{
	sichtbar = s;
	selected &= sichtbar;
}

// constant
bool VertexData::istSichtbar() const
{
	return sichtbar;
}

bool VertexData::istAusgewählt() const
{
	return selected;
}

Vec2< float > VertexData::getPos() const
{
	return vertex;
}

Punkt VertexData::getTPos() const
{
	return textur;
}

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

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


// Inhalt der PolygonData Klasse aus Data.h
// Konstruktor
PolygonData::PolygonData( Polygon2D &pg )
{
	vd = new RCArray< VertexData >();
	sichtbar = 1;
	ref = 1;
	int anz = pg.vertex->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
	{
		Vec2< float > v( 0, 0 );
		Punkt t( 0, 0 );
		if( pg.vertex->hat( i ) )
			v = pg.vertex->get( i );
		if( pg.tKordinaten && pg.tKordinaten->hat( i ) )
			t = pg.tKordinaten->get( i );
		vd->add( new VertexData( v, t ) );
	}
}

// Destruktor
PolygonData::~PolygonData()
{
	vd->release();
}

// nicht constant
void PolygonData::addVertex( Vec2< float >v, Punkt t )
{
	vd->add( new VertexData( v, t ) );
}

void PolygonData::removeVertex( int num )
{
	vd->remove( num );
}

void PolygonData::nachLinks( float num )
{
	for( auto *i = &vd->getArray(); i && i->set; i = i->next )
		i->var->nachLinks( num );
}

void PolygonData::nachOben( float num )
{
	for( auto *i = &vd->getArray(); i && i->set; i = i->next )
		i->var->nachOben( num );
}

void PolygonData::saveTextur( Punkt tPos )
{
	for( auto *i = &vd->getArray(); i && i->set; i = i->next )
		i->var->saveTextur( tPos );
}

void PolygonData::select( Punkt p1, Punkt p2 )
{
	for( auto *i = &vd->getArray(); i && i->set; i = i->next )
		i->var->select( p1, p2 );
}

void PolygonData::deSelect()
{
	for( auto *i = &vd->getArray(); i && i->set; i = i->next )
		i->var->deSelect();
}

void PolygonData::setSichtbar( bool s )
{
	sichtbar = s;
}

// constant
bool PolygonData::istSichtbar() const
{
	return sichtbar;
}

VertexData *PolygonData::zVertex( int num ) const
{
	return vd->z( num );
}

int PolygonData::getVertexAnzahl() const
{
	return vd->getEintragAnzahl();
}

void PolygonData::getM2( Polygon2D &pd, bool textur ) const
{
	int anz = vd->getEintragAnzahl();
	if( !pd.vertex )
		pd.vertex = new Array< Vertex >();
	if( !pd.tKordinaten )
		pd.tKordinaten = new Array< Punkt >();
	for( int i = 0; i < anz; i++ )
	{
		pd.vertex->add( this->vd->z( i )->getPos() );
		if( textur )
			 pd.tKordinaten->add( this->vd->z( i )->getTPos() );
	}
}

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

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


// Inhalt der Data Klasse aus Data.h
// Konstruktor
Data::Data( Model2DData *mdl )
{
	pd = new RCArray< PolygonData >();
	tPos.x = 0;
	tPos.y = 0;
	textur = 0;
	rTextur = 0;
	sp = -1;
	ref = 1;
	int anz = ( mdl && mdl->polygons ) ? mdl->polygons->getEintragAnzahl() : 0;
	for( int i = 0; i < anz; i++ )
	{
		if( mdl->polygons->hat( i ) )
		{
			pd->add( new PolygonData( mdl->polygons->get( i ) ) );
			if( !tPos.x && !tPos.y )
			{
				if( mdl->polygons->get( i ).tKordinaten && mdl->polygons->get( i ).vertex
					&& mdl->polygons->get( i ).tKordinaten->hat( 0 ) && mdl->polygons->get( i ).vertex->hat( 0 ) )
				{
					Punkt p = (Punkt)mdl->polygons->get( i ).vertex->get( 0 );
					Punkt tp = mdl->polygons->get( i ).tKordinaten->get( 0 );
					tPos = p - tp;
				}
			}
		}
	}
	if( mdl )
		mdl->release();
}

// Destruktor
Data::~Data()
{
	pd->release();
	if( textur )
		textur->release();
}

// nicht constant
void Data::addPolygon()
{
	Polygon2D p;
	p.vertex = new Array< Vertex >();
	pd->add( new PolygonData( p ) );
	p.vertex->release();
}

void Data::removePolygon( int num )
{
	pd->remove( num );
	if( sp == num )
		sp = -1;
}

void Data::selectPolygon( int num )
{
	sp = num;
}

void Data::nachLinks( float num )
{
	for( auto *i = &pd->getArray(); i && i->set; i = i->next )
		i->var->nachLinks( num );
}

void Data::nachOben( float num )
{
	for( auto *i = &pd->getArray(); i && i->set; i = i->next )
		i->var->nachOben( num );
}

void Data::tNachLinks( int num )
{
	if( !rTextur )
		return;
	tPos.x -= num;
}

void Data::tNachOben( int num )
{
	if( !rTextur )
		return;
	tPos.y -= num;
}

void Data::setRTextur( bool rt )
{
	rTextur = rt;
	if( rt && !textur )
	{
		textur = new Bild();
		textur->neuBild( 500, 500, 0xFF505000 );
	}
}

void Data::saveTextur()
{
	if( !rTextur )
		return;
	for( auto *i = &pd->getArray(); i && i->set; i = i->next )
		i->var->saveTextur( tPos );
}

void Data::setTextur( Bild *t )
{
	if( textur )
		textur->release();
	textur = t;
}

void Data::select( Punkt p1, Punkt p2 )
{
	for( auto *i = &pd->getArray(); i && i->set; i = i->next )
		i->var->select( p1, p2 );
}

void Data::deSelect()
{
	for( auto *i = &pd->getArray(); i && i->set; i = i->next )
		i->var->deSelect();
}

// constant
PolygonData *Data::zPolygon( int num ) const
{
	return pd->z( num );
}

int Data::getPolygonAnzahl() const
{
	return pd->getEintragAnzahl();
}

int Data::getSelectedPolygon() const
{
	return sp;
}

Model2DData *Data::getM2() const
{
	int anz = pd->getEintragAnzahl();
	Array< Polygon2D > *polygons = new Array< Polygon2D >();
	for( int i = 0; i < anz; i++ )
	{
		Polygon2D pd = { 0, 0 };
		this->pd->z( i )->getM2( pd, rTextur );
		polygons->add( pd );
	}
	Model2DData *ret = new Model2DData();
	ret->erstelleModell( polygons );
	return ret;
}

Bild *Data::zTextur() const
{
	return rTextur ? textur : 0;
}

Punkt Data::getTPos() const
{
	return tPos;
}

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

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