|
@@ -36,21 +36,21 @@ Knochen::~Knochen()
|
|
|
|
|
|
// Setzt die Position des Knochens relativ zum Model Ursprung
|
|
// Setzt die Position des Knochens relativ zum Model Ursprung
|
|
// pos: Die Position
|
|
// pos: Die Position
|
|
-void Knochen::setPosition( Vec3< float > &pos )
|
|
|
|
|
|
+void Knochen::setPosition( Vec3< float >& pos )
|
|
{
|
|
{
|
|
this->pos = pos;
|
|
this->pos = pos;
|
|
}
|
|
}
|
|
|
|
|
|
// Setzt die Drehung des Knochens relativ zum Model Ursprung
|
|
// Setzt die Drehung des Knochens relativ zum Model Ursprung
|
|
// winkel: Ein Vektor der die Drehung um die verschiedenen Achsen als Komponenten hat
|
|
// winkel: Ein Vektor der die Drehung um die verschiedenen Achsen als Komponenten hat
|
|
-void Knochen::setDrehung( Vec3< float > &winkel )
|
|
|
|
|
|
+void Knochen::setDrehung( Vec3< float >& winkel )
|
|
{
|
|
{
|
|
this->winkel = winkel;
|
|
this->winkel = winkel;
|
|
}
|
|
}
|
|
|
|
|
|
// Fügt dem Knochen ein Geschwister Knochen hinzu
|
|
// Fügt dem Knochen ein Geschwister Knochen hinzu
|
|
// k: Der Knochen, der hinzugefügt werden soll
|
|
// k: Der Knochen, der hinzugefügt werden soll
|
|
-void Knochen::addGeschwisterKnochen( Knochen *k )
|
|
|
|
|
|
+void Knochen::addGeschwisterKnochen( Knochen* k )
|
|
{
|
|
{
|
|
if( !geschwister )
|
|
if( !geschwister )
|
|
geschwister = k;
|
|
geschwister = k;
|
|
@@ -61,7 +61,7 @@ void Knochen::addGeschwisterKnochen( Knochen *k )
|
|
// Fügt einem bestimmten Knochen ein Kind Knochen hinzu
|
|
// Fügt einem bestimmten Knochen ein Kind Knochen hinzu
|
|
// id: Die id des Knochens, wo der Knochen als Kind hinzugefügt werden soll
|
|
// id: Die id des Knochens, wo der Knochen als Kind hinzugefügt werden soll
|
|
// k: Der Knochen, der hinzugefügt werden soll
|
|
// k: Der Knochen, der hinzugefügt werden soll
|
|
-void Knochen::addKind( int id, Knochen *k )
|
|
|
|
|
|
+void Knochen::addKind( int id, Knochen* k )
|
|
{
|
|
{
|
|
if( this->id == id )
|
|
if( this->id == id )
|
|
{
|
|
{
|
|
@@ -82,7 +82,7 @@ void Knochen::addKind( int id, Knochen *k )
|
|
err += __LINE__;
|
|
err += __LINE__;
|
|
err += "!";
|
|
err += "!";
|
|
delete k;
|
|
delete k;
|
|
- throw std::out_of_range( (const char *)err );
|
|
|
|
|
|
+ throw std::out_of_range( (const char*)err );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -92,7 +92,7 @@ void Knochen::addKind( int id, Knochen *k )
|
|
// matBuffer: Ein Array, in dem alle berechneten Matrizen gespeichert werden sollen
|
|
// matBuffer: Ein Array, in dem alle berechneten Matrizen gespeichert werden sollen
|
|
// scaleFactor: Die Skallierung des Modells
|
|
// scaleFactor: Die Skallierung des Modells
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
-void Knochen::kalkulateMatrix( Mat4< float > &elternMat, Mat4< float > *matBuffer, float scaleFactor, Mat4< float > &kamMat )
|
|
|
|
|
|
+void Knochen::kalkulateMatrix( Mat4< float >& elternMat, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMat )
|
|
{
|
|
{
|
|
if( geschwister )
|
|
if( geschwister )
|
|
geschwister->kalkulateMatrix( elternMat, matBuffer, scaleFactor, kamMat );
|
|
geschwister->kalkulateMatrix( elternMat, matBuffer, scaleFactor, kamMat );
|
|
@@ -103,20 +103,20 @@ void Knochen::kalkulateMatrix( Mat4< float > &elternMat, Mat4< float > *matBuffe
|
|
matBuffer[ id ] = kamMat * matBuffer[ id ];
|
|
matBuffer[ id ] = kamMat * matBuffer[ id ];
|
|
}
|
|
}
|
|
|
|
|
|
-Knochen *Framework::Knochen::zGeschwister() const
|
|
|
|
|
|
+Knochen* Framework::Knochen::zGeschwister() const
|
|
{
|
|
{
|
|
return geschwister;
|
|
return geschwister;
|
|
}
|
|
}
|
|
|
|
|
|
-Knochen *Framework::Knochen::zKind() const
|
|
|
|
|
|
+Knochen* Framework::Knochen::zKind() const
|
|
{
|
|
{
|
|
return kinder;
|
|
return kinder;
|
|
}
|
|
}
|
|
|
|
|
|
// Kopiert den Knochen mit allen Geschwister Knochen und Kind Knochen
|
|
// Kopiert den Knochen mit allen Geschwister Knochen und Kind Knochen
|
|
-Knochen *Knochen::kopiereKnochen() const
|
|
|
|
|
|
+Knochen* Knochen::kopiereKnochen() const
|
|
{
|
|
{
|
|
- Knochen *ret = new Knochen( id );
|
|
|
|
|
|
+ Knochen* ret = new Knochen( id );
|
|
ret->pos = pos;
|
|
ret->pos = pos;
|
|
ret->winkel = winkel;
|
|
ret->winkel = winkel;
|
|
if( geschwister )
|
|
if( geschwister )
|
|
@@ -187,7 +187,7 @@ void Framework::Skelett::setNextKnochenId( int id )
|
|
// Fügt dem Skellet einen Knochen hinzu
|
|
// Fügt dem Skellet einen Knochen hinzu
|
|
// k: Der Knochen
|
|
// k: Der Knochen
|
|
// elternId: Die Id des Eltern Knochens. Wenn der Knochen kein Elternknochen besitzt, kannder Parameter weggelassen werden.
|
|
// elternId: Die Id des Eltern Knochens. Wenn der Knochen kein Elternknochen besitzt, kannder Parameter weggelassen werden.
|
|
-void Skelett::addKnochen( Knochen *k, int elternId )
|
|
|
|
|
|
+void Skelett::addKnochen( Knochen* k, int elternId )
|
|
{
|
|
{
|
|
if( !this->k )
|
|
if( !this->k )
|
|
this->k = k;
|
|
this->k = k;
|
|
@@ -203,7 +203,7 @@ void Skelett::addKnochen( Knochen *k, int elternId )
|
|
// scaleFactor: Die skallierung des Objektes
|
|
// scaleFactor: Die skallierung des Objektes
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
// return: gibt die Anzahl der verwendeten Matrizen zurück
|
|
// return: gibt die Anzahl der verwendeten Matrizen zurück
|
|
-int Skelett::kalkulateMatrix( Mat4< float > &modelMatrix, Mat4< float > *matBuffer, float scaleFactor, Mat4< float > &kamMatrix )
|
|
|
|
|
|
+int Skelett::kalkulateMatrix( Mat4< float >& modelMatrix, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMatrix )
|
|
{
|
|
{
|
|
k->kalkulateMatrix( modelMatrix, matBuffer, scaleFactor, kamMatrix );
|
|
k->kalkulateMatrix( modelMatrix, matBuffer, scaleFactor, kamMatrix );
|
|
return nextId;
|
|
return nextId;
|
|
@@ -218,15 +218,15 @@ float Skelett::getRadius() const
|
|
}
|
|
}
|
|
|
|
|
|
// gibt den Wurzel Knochen zurück
|
|
// gibt den Wurzel Knochen zurück
|
|
-Knochen *Framework::Skelett::zKnochen() const
|
|
|
|
|
|
+Knochen* Framework::Skelett::zKnochen() const
|
|
{
|
|
{
|
|
return k;
|
|
return k;
|
|
}
|
|
}
|
|
|
|
|
|
// Kopiert das Skelett
|
|
// Kopiert das Skelett
|
|
-Skelett *Skelett::kopiereSkelett() const
|
|
|
|
|
|
+Skelett* Skelett::kopiereSkelett() const
|
|
{
|
|
{
|
|
- Skelett *ret = new Skelett();
|
|
|
|
|
|
+ Skelett* ret = new Skelett();
|
|
ret->nextId = nextId;
|
|
ret->nextId = nextId;
|
|
if( k )
|
|
if( k )
|
|
ret->addKnochen( k->kopiereKnochen() );
|
|
ret->addKnochen( k->kopiereKnochen() );
|
|
@@ -263,7 +263,7 @@ Model3DData::Model3DData()
|
|
skelett = 0;
|
|
skelett = 0;
|
|
vertexList = 0;
|
|
vertexList = 0;
|
|
vertexCount = 0;
|
|
vertexCount = 0;
|
|
- polygons = new Array< Polygon3D * >();
|
|
|
|
|
|
+ polygons = new Array< Polygon3D* >();
|
|
ambientFactor = 1.f;
|
|
ambientFactor = 1.f;
|
|
diffusFactor = 0.f;
|
|
diffusFactor = 0.f;
|
|
specularFactor = 0.f;
|
|
specularFactor = 0.f;
|
|
@@ -286,7 +286,7 @@ void Model3DData::clearModel()
|
|
delete[] vertexList;
|
|
delete[] vertexList;
|
|
vertexCount = 0;
|
|
vertexCount = 0;
|
|
vertexList = 0;
|
|
vertexList = 0;
|
|
- for( auto i = polygons->getIterator(); i; i++ )
|
|
|
|
|
|
+ for( Polygon3D* i : *polygons )
|
|
delete i;
|
|
delete i;
|
|
polygons->leeren();
|
|
polygons->leeren();
|
|
if( skelett )
|
|
if( skelett )
|
|
@@ -304,7 +304,7 @@ void Model3DData::calculateNormals()
|
|
for( int i = 0; i < vertexCount; i++ )
|
|
for( int i = 0; i < vertexCount; i++ )
|
|
{
|
|
{
|
|
Vec3< float > normal( 0, 0, 0 );
|
|
Vec3< float > normal( 0, 0, 0 );
|
|
- for( auto p = polygons->getIterator(); p; p++ )
|
|
|
|
|
|
+ for( Polygon3D* p : *polygons )
|
|
{
|
|
{
|
|
int begin = 0;
|
|
int begin = 0;
|
|
for( int j = 0; j < p->indexAnz; j++ )
|
|
for( int j = 0; j < p->indexAnz; j++ )
|
|
@@ -316,7 +316,7 @@ void Model3DData::calculateNormals()
|
|
Vec3< float > a = vertexList[ p->indexList[ begin ] ].pos;
|
|
Vec3< float > a = vertexList[ p->indexList[ begin ] ].pos;
|
|
Vec3< float > b = vertexList[ p->indexList[ begin + 1 ] ].pos;
|
|
Vec3< float > b = vertexList[ p->indexList[ begin + 1 ] ].pos;
|
|
Vec3< float > c = vertexList[ p->indexList[ begin + 2 ] ].pos;
|
|
Vec3< float > c = vertexList[ p->indexList[ begin + 2 ] ].pos;
|
|
- normal += ( b - a ).crossProduct( c - a ).normalize();
|
|
|
|
|
|
+ normal += (b - a).crossProduct( c - a ).normalize();
|
|
normal.normalize();
|
|
normal.normalize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -330,11 +330,11 @@ void Model3DData::buildIndexBuffer()
|
|
{
|
|
{
|
|
delete[] indexBuffer;
|
|
delete[] indexBuffer;
|
|
indexCount = 0;
|
|
indexCount = 0;
|
|
- for( auto p = polygons->getIterator(); p; p++ )
|
|
|
|
|
|
+ for( Polygon3D* p : *polygons )
|
|
indexCount += p->indexAnz;
|
|
indexCount += p->indexAnz;
|
|
indexBuffer = new int[ indexCount ];
|
|
indexBuffer = new int[ indexCount ];
|
|
int current = 0;
|
|
int current = 0;
|
|
- for( auto p = polygons->getIterator(); p; p++ )
|
|
|
|
|
|
+ for( Polygon3D* p : *polygons )
|
|
{
|
|
{
|
|
memcpy( indexBuffer + current, p->indexList, sizeof( int ) * p->indexAnz );
|
|
memcpy( indexBuffer + current, p->indexList, sizeof( int ) * p->indexAnz );
|
|
current += p->indexAnz;
|
|
current += p->indexAnz;
|
|
@@ -343,7 +343,7 @@ void Model3DData::buildIndexBuffer()
|
|
|
|
|
|
// Setzt den Zeiger auf ein standartmäßig verwendete Skelett
|
|
// Setzt den Zeiger auf ein standartmäßig verwendete Skelett
|
|
// s: Das Skelett, das verwendet werden soll
|
|
// s: Das Skelett, das verwendet werden soll
|
|
-void Model3DData::setSkelettZ( Skelett *s )
|
|
|
|
|
|
+void Model3DData::setSkelettZ( Skelett* s )
|
|
{
|
|
{
|
|
if( skelett )
|
|
if( skelett )
|
|
skelett->release();
|
|
skelett->release();
|
|
@@ -353,7 +353,7 @@ void Model3DData::setSkelettZ( Skelett *s )
|
|
// Setzt einen Zeiger auf eine Liste mit allen Vertecies des Models
|
|
// Setzt einen Zeiger auf eine Liste mit allen Vertecies des Models
|
|
// vertexList: Ein Array mit Vertecies
|
|
// vertexList: Ein Array mit Vertecies
|
|
// anz: Die Anzahl der Vertecies im Array
|
|
// anz: Die Anzahl der Vertecies im Array
|
|
-void Model3DData::setVertecies( Vertex3D *vertexList, int anz )
|
|
|
|
|
|
+void Model3DData::setVertecies( Vertex3D* vertexList, int anz )
|
|
{
|
|
{
|
|
delete[] this->vertexList;
|
|
delete[] this->vertexList;
|
|
this->vertexList = vertexList;
|
|
this->vertexList = vertexList;
|
|
@@ -369,7 +369,7 @@ void Model3DData::setVertecies( Vertex3D *vertexList, int anz )
|
|
|
|
|
|
// Fügt ein Polygon zum Model hinzu
|
|
// Fügt ein Polygon zum Model hinzu
|
|
// polygon: Das Polygon, das hinzugefügt erden soll
|
|
// polygon: Das Polygon, das hinzugefügt erden soll
|
|
-void Model3DData::addPolygon( Polygon3D *polygon )
|
|
|
|
|
|
+void Model3DData::addPolygon( Polygon3D* polygon )
|
|
{
|
|
{
|
|
polygons->add( polygon );
|
|
polygons->add( polygon );
|
|
buildIndexBuffer();
|
|
buildIndexBuffer();
|
|
@@ -399,33 +399,33 @@ void Model3DData::setSpecularFactor( float f )
|
|
// Konvertiert ein 2d Model zu 3D
|
|
// Konvertiert ein 2d Model zu 3D
|
|
// model: Das 2d Model, das zu 3d konvertiert werden soll
|
|
// model: Das 2d Model, das zu 3d konvertiert werden soll
|
|
// z: Die z koordinate aller punkte des Models
|
|
// z: Die z koordinate aller punkte des Models
|
|
-void Model3DData::copyModel2D( Model2DData *model, float z )
|
|
|
|
|
|
+void Model3DData::copyModel2D( Model2DData* model, float z )
|
|
{
|
|
{
|
|
if( model && model->vListen && model->polygons )
|
|
if( model && model->vListen && model->polygons )
|
|
{
|
|
{
|
|
clearModel();
|
|
clearModel();
|
|
int vAnz = 0;
|
|
int vAnz = 0;
|
|
- for( auto i = model->polygons->getIterator(); i; i++ )
|
|
|
|
- vAnz += i._.vertex->getEintragAnzahl();
|
|
|
|
|
|
+ for( Polygon2D p : *model->polygons )
|
|
|
|
+ vAnz += p.vertex->getEintragAnzahl();
|
|
vertexList = new Vertex3D[ vAnz ];
|
|
vertexList = new Vertex3D[ vAnz ];
|
|
int index = 0;
|
|
int index = 0;
|
|
- for( auto i = model->vListen->getIterator(); i; i++ )
|
|
|
|
|
|
+ for( auto i : *model->vListen )
|
|
{
|
|
{
|
|
- Polygon3D *p = new Polygon3D();
|
|
|
|
|
|
+ Polygon3D* p = new Polygon3D();
|
|
p->indexAnz = 0;
|
|
p->indexAnz = 0;
|
|
- for( auto j = i->getIterator(); j; j++ )
|
|
|
|
|
|
+ for( auto j : *i )
|
|
{
|
|
{
|
|
- for( auto k = j->zListe()->getIterator(); k.hasNext() && k.next().hasNext(); k++ )
|
|
|
|
|
|
+ for( auto k = j->zListe()->begin(); k.hasNext() && k.next().hasNext(); k++ )
|
|
p->indexAnz += 3;
|
|
p->indexAnz += 3;
|
|
}
|
|
}
|
|
p->indexList = new int[ p->indexAnz ];
|
|
p->indexList = new int[ p->indexAnz ];
|
|
p->indexAnz = 0;
|
|
p->indexAnz = 0;
|
|
- for( auto j = i->getIterator(); j; j++ )
|
|
|
|
|
|
+ for( auto j : *i )
|
|
{
|
|
{
|
|
- for( auto k = j->zListe()->getIterator(); k; k++ )
|
|
|
|
|
|
+ for( auto k = j->zListe()->begin(); k; k++ )
|
|
{
|
|
{
|
|
vertexList[ index ].pos = Vec3< float >( k->punkt->x, k->punkt->y, z );
|
|
vertexList[ index ].pos = Vec3< float >( k->punkt->x, k->punkt->y, z );
|
|
- vertexList[ index ].tPos = ( Vec2< float > ) * k->textur;
|
|
|
|
|
|
+ vertexList[ index ].tPos = (Vec2< float >) * k->textur;
|
|
if( k.hasNext() && k.next().hasNext() )
|
|
if( k.hasNext() && k.next().hasNext() )
|
|
{
|
|
{
|
|
p->indexList[ p->indexAnz ] = index;
|
|
p->indexList[ p->indexAnz ] = index;
|
|
@@ -460,7 +460,7 @@ void Model3DData::removePolygon( int index )
|
|
// scaleFactor: Die Skallierung des Modells
|
|
// scaleFactor: Die Skallierung des Modells
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
// kamMatrix: Die vereiniegung der view und projektions Matrizen
|
|
// return: gibt die Anzahl der verwendeten Matrizen zurück
|
|
// return: gibt die Anzahl der verwendeten Matrizen zurück
|
|
-int Model3DData::kalkulateMatrix( Mat4< float > &modelMatrix, Mat4< float > *matBuffer, float scaleFactor, Mat4< float > &kamMatrix ) const
|
|
|
|
|
|
+int Model3DData::kalkulateMatrix( Mat4< float >& modelMatrix, Mat4< float >* matBuffer, float scaleFactor, Mat4< float >& kamMatrix ) const
|
|
{
|
|
{
|
|
if( !skelett )
|
|
if( !skelett )
|
|
return 0;
|
|
return 0;
|
|
@@ -475,7 +475,7 @@ int Model3DData::getPolygonAnzahl() const
|
|
|
|
|
|
// Gibt ein bestimmtes Polygon zurück
|
|
// Gibt ein bestimmtes Polygon zurück
|
|
// index: Der Index des Polygons
|
|
// index: Der Index des Polygons
|
|
-Polygon3D *Model3DData::getPolygon( int index ) const
|
|
|
|
|
|
+Polygon3D* Model3DData::getPolygon( int index ) const
|
|
{
|
|
{
|
|
if( !polygons->hat( index ) )
|
|
if( !polygons->hat( index ) )
|
|
return 0;
|
|
return 0;
|
|
@@ -483,9 +483,9 @@ Polygon3D *Model3DData::getPolygon( int index ) const
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt einen Iterator zurück, mit dem sich die Polygons auflisten lassen
|
|
// Gibt einen Iterator zurück, mit dem sich die Polygons auflisten lassen
|
|
-Iterator< Polygon3D * > Model3DData::getPolygons() const
|
|
|
|
|
|
+Iterator< Polygon3D* > Model3DData::getPolygons() const
|
|
{
|
|
{
|
|
- return polygons->getIterator();
|
|
|
|
|
|
+ return polygons->begin();
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
|
|
// Gibt den radius einer Kugel zurück, die das gesammte Model umschließt
|
|
@@ -519,7 +519,7 @@ float Model3DData::getSpecularFactor() const
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt eine Kopie des Skeletts zurück, welches für annimationen verwendet werden kann
|
|
// Gibt eine Kopie des Skeletts zurück, welches für annimationen verwendet werden kann
|
|
-Skelett *Model3DData::copySkelett() const
|
|
|
|
|
|
+Skelett* Model3DData::copySkelett() const
|
|
{
|
|
{
|
|
return skelett ? skelett->kopiereSkelett() : 0;
|
|
return skelett ? skelett->kopiereSkelett() : 0;
|
|
}
|
|
}
|
|
@@ -531,13 +531,13 @@ int Model3DData::getVertexAnzahl() const
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt einen Buffer mit allen Vertecies des Models zurück
|
|
// Gibt einen Buffer mit allen Vertecies des Models zurück
|
|
-const Vertex3D *Model3DData::zVertexBuffer() const
|
|
|
|
|
|
+const Vertex3D* Model3DData::zVertexBuffer() const
|
|
{
|
|
{
|
|
return vertexList;
|
|
return vertexList;
|
|
}
|
|
}
|
|
|
|
|
|
//! Gibt eine refferenz auf den beginn des indexBuffers zurück
|
|
//! Gibt eine refferenz auf den beginn des indexBuffers zurück
|
|
-const int *Model3DData::getIndexBuffer() const
|
|
|
|
|
|
+const int* Model3DData::getIndexBuffer() const
|
|
{
|
|
{
|
|
return indexBuffer;
|
|
return indexBuffer;
|
|
}
|
|
}
|
|
@@ -567,7 +567,7 @@ Model3DTextur::~Model3DTextur()
|
|
// Legt fest, welche Textur für welches Polygon ist
|
|
// Legt fest, welche Textur für welches Polygon ist
|
|
// pI: Der Index des Polygons
|
|
// pI: Der Index des Polygons
|
|
// txt: Die Textur des Polygons
|
|
// txt: Die Textur des Polygons
|
|
-void Model3DTextur::setPolygonTextur( int pI, Textur *txt )
|
|
|
|
|
|
+void Model3DTextur::setPolygonTextur( int pI, Textur* txt )
|
|
{
|
|
{
|
|
while( pI > textures->getLastIndex() )
|
|
while( pI > textures->getLastIndex() )
|
|
textures->add( 0 );
|
|
textures->add( 0 );
|
|
@@ -576,18 +576,18 @@ void Model3DTextur::setPolygonTextur( int pI, Textur *txt )
|
|
|
|
|
|
// Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten Reference Counter
|
|
// Gibt einen Zeiger auf die Textur eines Polygons zurück ohne erhöhten Reference Counter
|
|
// i: Der Index des Polygons
|
|
// i: Der Index des Polygons
|
|
-Textur *Model3DTextur::zPolygonTextur( int i ) const
|
|
|
|
|
|
+Textur* Model3DTextur::zPolygonTextur( int i ) const
|
|
{
|
|
{
|
|
return textures->z( i );
|
|
return textures->z( i );
|
|
}
|
|
}
|
|
|
|
|
|
// Inhalt der AnimationData Struktur
|
|
// Inhalt der AnimationData Struktur
|
|
-Model3D::AnimationData *Model3D::AnimationData::getThis()
|
|
|
|
|
|
+Model3D::AnimationData* Model3D::AnimationData::getThis()
|
|
{
|
|
{
|
|
return this;
|
|
return this;
|
|
}
|
|
}
|
|
|
|
|
|
-Model3D::AnimationData *Model3D::AnimationData::release()
|
|
|
|
|
|
+Model3D::AnimationData* Model3D::AnimationData::release()
|
|
{
|
|
{
|
|
a->release();
|
|
a->release();
|
|
delete this;
|
|
delete this;
|
|
@@ -622,9 +622,9 @@ Model3D::~Model3D()
|
|
|
|
|
|
// Fügt eine Animation hinzu
|
|
// Fügt eine Animation hinzu
|
|
// a: Die neue Animation
|
|
// a: Die neue Animation
|
|
-void Model3D::addAnimation( Animation3D *a, double speed )
|
|
|
|
|
|
+void Model3D::addAnimation( Animation3D* a, double speed )
|
|
{
|
|
{
|
|
- AnimationData *d = new AnimationData();
|
|
|
|
|
|
+ AnimationData* d = new AnimationData();
|
|
d->a = a;
|
|
d->a = a;
|
|
d->speed = speed;
|
|
d->speed = speed;
|
|
d->offset = 0;
|
|
d->offset = 0;
|
|
@@ -633,7 +633,7 @@ void Model3D::addAnimation( Animation3D *a, double speed )
|
|
|
|
|
|
// Entfernt eine Animation
|
|
// Entfernt eine Animation
|
|
// zA: Die zu entfernende Animation
|
|
// zA: Die zu entfernende Animation
|
|
-void Model3D::removeAnimation( Animation3D *zA )
|
|
|
|
|
|
+void Model3D::removeAnimation( Animation3D* zA )
|
|
{
|
|
{
|
|
for( int i = 0; i < animations->getEintragAnzahl(); i++ )
|
|
for( int i = 0; i < animations->getEintragAnzahl(); i++ )
|
|
{
|
|
{
|
|
@@ -647,12 +647,12 @@ void Model3D::removeAnimation( Animation3D *zA )
|
|
|
|
|
|
// Setzt die Daten des Models
|
|
// Setzt die Daten des Models
|
|
// data: Die Daten
|
|
// data: Die Daten
|
|
-void Model3D::setModelDaten( Model3DData *data )
|
|
|
|
|
|
+void Model3D::setModelDaten( Model3DData* data )
|
|
{
|
|
{
|
|
if( model )
|
|
if( model )
|
|
model->release();
|
|
model->release();
|
|
if( skelett )
|
|
if( skelett )
|
|
- skelett = (Skelett *)skelett->release();
|
|
|
|
|
|
+ skelett = (Skelett*)skelett->release();
|
|
model = data;
|
|
model = data;
|
|
if( model )
|
|
if( model )
|
|
{
|
|
{
|
|
@@ -665,7 +665,7 @@ void Model3D::setModelDaten( Model3DData *data )
|
|
|
|
|
|
// Setzt die zum Zeichnen zu benutzenden Texturen
|
|
// Setzt die zum Zeichnen zu benutzenden Texturen
|
|
// txt: Ein Liste mit Texturen zu den verschiedenen Polygonen zugeordnet
|
|
// txt: Ein Liste mit Texturen zu den verschiedenen Polygonen zugeordnet
|
|
-void Model3D::setModelTextur( Model3DTextur *txt )
|
|
|
|
|
|
+void Model3D::setModelTextur( Model3DTextur* txt )
|
|
{
|
|
{
|
|
if( textur )
|
|
if( textur )
|
|
textur->release();
|
|
textur->release();
|
|
@@ -697,7 +697,7 @@ void Framework::Model3D::setSpecularFactor( float f )
|
|
// viewProj: Die miteinander multiplizierten Kameramatrizen
|
|
// viewProj: Die miteinander multiplizierten Kameramatrizen
|
|
// matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
|
|
// matBuffer: Ein Array mit Matrizen, der gefüllt werden soll
|
|
// return: Die Anzahl der Matrizen, die das Model benötigt
|
|
// return: Die Anzahl der Matrizen, die das Model benötigt
|
|
-int Model3D::errechneMatrizen( Mat4< float > &viewProj, Mat4< float > *matBuffer )
|
|
|
|
|
|
+int Model3D::errechneMatrizen( Mat4< float >& viewProj, Mat4< float >* matBuffer )
|
|
{
|
|
{
|
|
int ret = 0;
|
|
int ret = 0;
|
|
if( skelett )
|
|
if( skelett )
|
|
@@ -718,7 +718,7 @@ bool Model3D::tick( double tickval )
|
|
if( skelett )
|
|
if( skelett )
|
|
{
|
|
{
|
|
radius += skelett->getRadius();
|
|
radius += skelett->getRadius();
|
|
- for( auto i = animations->getIterator(); i && i._; i++ )
|
|
|
|
|
|
+ for( auto i = animations->begin(); i && i._; i++ )
|
|
{
|
|
{
|
|
rend = i->speed > 0;
|
|
rend = i->speed > 0;
|
|
i->a->apply( skelett, i->offset, tickval * i->speed );
|
|
i->a->apply( skelett, i->offset, tickval * i->speed );
|
|
@@ -728,25 +728,25 @@ bool Model3D::tick( double tickval )
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt die Textur zurück
|
|
// Gibt die Textur zurück
|
|
-Model3DTextur *Model3D::getTextur()
|
|
|
|
|
|
+Model3DTextur* Model3D::getTextur()
|
|
{
|
|
{
|
|
- return textur ? dynamic_cast<Model3DTextur *>( textur->getThis() ) : 0;
|
|
|
|
|
|
+ return textur ? dynamic_cast<Model3DTextur*>(textur->getThis()) : 0;
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt die Textur zurück (ohne erhöhten Reference Counter)
|
|
// Gibt die Textur zurück (ohne erhöhten Reference Counter)
|
|
-Model3DTextur *Model3D::zTextur()
|
|
|
|
|
|
+Model3DTextur* Model3D::zTextur()
|
|
{
|
|
{
|
|
return textur;
|
|
return textur;
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt die ModelDaten zurück
|
|
// Gibt die ModelDaten zurück
|
|
-Model3DData *Model3D::getModelData()
|
|
|
|
|
|
+Model3DData* Model3D::getModelData()
|
|
{
|
|
{
|
|
- return model ? dynamic_cast<Model3DData *>( model->getThis() ) : 0;
|
|
|
|
|
|
+ return model ? dynamic_cast<Model3DData*>(model->getThis()) : 0;
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt die ModelDaten zurück (ohne erhöhten Reference Counter)
|
|
// Gibt die ModelDaten zurück (ohne erhöhten Reference Counter)
|
|
-Model3DData *Model3D::zModelData()
|
|
|
|
|
|
+Model3DData* Model3D::zModelData()
|
|
{
|
|
{
|
|
return model;
|
|
return model;
|
|
}
|
|
}
|
|
@@ -757,7 +757,7 @@ Model3DData *Model3D::zModelData()
|
|
// maxSqDist: Die maximale quadratische distanz die erlaubt ist
|
|
// maxSqDist: Die maximale quadratische distanz die erlaubt ist
|
|
// pId: die Id des Polygons, zu dem der Schnittpunkt gehört
|
|
// pId: die Id des Polygons, zu dem der Schnittpunkt gehört
|
|
// return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert
|
|
// return: den quadratischen Abstand des Schnittpunktes zum Ursprung des Strahls oder -1, wenn kein schnittpunkt existiert
|
|
-float Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, float maxSqDist, int &pId ) const
|
|
|
|
|
|
+float Model3D::traceRay( Vec3< float >& p, Vec3< float >& d, float maxSqDist, int& pId ) const
|
|
{
|
|
{
|
|
if( !model )
|
|
if( !model )
|
|
return -1;
|
|
return -1;
|
|
@@ -770,9 +770,9 @@ float Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, float maxSqDist, in
|
|
point.rotateX( -angle.x );
|
|
point.rotateX( -angle.x );
|
|
point.rotateZ( -angle.z );
|
|
point.rotateZ( -angle.z );
|
|
point -= pos;
|
|
point -= pos;
|
|
- float nearest = ( -dir.x * point.x - dir.y * point.y - dir.z * point.z ) / ( dir.x * dir.x + dir.y * dir.y + dir.z * dir.z );
|
|
|
|
- float dist = ( point + dir * nearest ).getLengthSq();
|
|
|
|
- if( dist > ( radius * size ) * ( radius * size ) || ( dir * nearest ).getLength() - radius * size > sqrt( maxSqDist ) || ( nearest < 0 && ( dir * nearest ).getLengthSq() > radius * size * radius * size ) ) // es gibt kein schnittpunkt
|
|
|
|
|
|
+ float nearest = (-dir.x * point.x - dir.y * point.y - dir.z * point.z) / (dir.x * dir.x + dir.y * dir.y + dir.z * dir.z);
|
|
|
|
+ float dist = (point + dir * nearest).getLengthSq();
|
|
|
|
+ if( dist > (radius * size) * (radius * size) || (dir * nearest).getLength() - radius * size > sqrt( maxSqDist ) || (nearest < 0 && (dir * nearest).getLengthSq() > radius * size * radius * size) ) // es gibt kein schnittpunkt
|
|
return -1;
|
|
return -1;
|
|
bool existsHit = 0;
|
|
bool existsHit = 0;
|
|
if( skelett )
|
|
if( skelett )
|
|
@@ -791,16 +791,16 @@ float Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, float maxSqDist, in
|
|
Vec3< float > a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
|
|
Vec3< float > a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
|
|
Vec3< float > b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
|
|
Vec3< float > b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
|
|
Vec3< float > c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
|
|
Vec3< float > c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
|
|
- Vec3< float > normal = ( b - a ).crossProduct( c - a ).normalize();
|
|
|
|
|
|
+ Vec3< float > normal = (b - a).crossProduct( c - a ).normalize();
|
|
if( normal * dir < 0 ) // Prüfe ob die Normale in Richtung des Strahl ursprungs zeigt
|
|
if( normal * dir < 0 ) // Prüfe ob die Normale in Richtung des Strahl ursprungs zeigt
|
|
{
|
|
{
|
|
- nearest = ( a * normal - point * normal ) / ( dir * normal );
|
|
|
|
|
|
+ nearest = (a * normal - point * normal) / (dir * normal);
|
|
Vec3< float > hit = point + dir * nearest;
|
|
Vec3< float > hit = point + dir * nearest;
|
|
- if( ( b - a ).angle( hit - a ) <= ( b - a ).angle( c - a ) &&
|
|
|
|
- ( c - a ).angle( hit - a ) <= ( b - a ).angle( c - a ) &&
|
|
|
|
- ( a - b ).angle( hit - b ) <= ( a - b ).angle( c - b ) )
|
|
|
|
|
|
+ if( (b - a).angle( hit - a ) <= (b - a).angle( c - a ) &&
|
|
|
|
+ (c - a).angle( hit - a ) <= (b - a).angle( c - a ) &&
|
|
|
|
+ (a - b).angle( hit - b ) <= (a - b).angle( c - b ) )
|
|
{
|
|
{
|
|
- maxSqDist = ( hit - point ).getLengthSq();
|
|
|
|
|
|
+ maxSqDist = (hit - point).getLengthSq();
|
|
pId = index;
|
|
pId = index;
|
|
existsHit = 1;
|
|
existsHit = 1;
|
|
}
|
|
}
|
|
@@ -818,7 +818,7 @@ float Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, float maxSqDist, in
|
|
// dir: die Richtung des Strahls in Weltkoordinaten
|
|
// dir: die Richtung des Strahls in Weltkoordinaten
|
|
// zWelt: die Welt, aus der der Strahl kommt
|
|
// zWelt: die Welt, aus der der Strahl kommt
|
|
// return: die Farbe des Schnittpunktes
|
|
// return: die Farbe des Schnittpunktes
|
|
-int Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, int pId, Welt3D *zWelt ) const
|
|
|
|
|
|
+int Model3D::traceRay( Vec3< float >& p, Vec3< float >& d, int pId, Welt3D* zWelt ) const
|
|
{
|
|
{
|
|
Vec3< float > dir = d;
|
|
Vec3< float > dir = d;
|
|
dir.rotateY( -angle.y );
|
|
dir.rotateY( -angle.y );
|
|
@@ -838,23 +838,23 @@ int Model3D::traceRay( Vec3< float > &p, Vec3< float > &d, int pId, Welt3D *zWel
|
|
{
|
|
{
|
|
if( pId == 0 )
|
|
if( pId == 0 )
|
|
{
|
|
{
|
|
- const Vec3< float > &a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
|
|
|
|
- const Vec3< float > &b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
|
|
|
|
- const Vec3< float > &c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
|
|
|
|
|
|
+ const Vec3< float >& a = model->zVertexBuffer()[ p->indexList[ j ] ].pos;
|
|
|
|
+ const Vec3< float >& b = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].pos;
|
|
|
|
+ const Vec3< float >& c = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].pos;
|
|
Vertex at = model->zVertexBuffer()[ p->indexList[ j ] ].tPos;
|
|
Vertex at = model->zVertexBuffer()[ p->indexList[ j ] ].tPos;
|
|
Vertex bt = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].tPos;
|
|
Vertex bt = model->zVertexBuffer()[ p->indexList[ j + 1 ] ].tPos;
|
|
Vertex ct = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].tPos;
|
|
Vertex ct = model->zVertexBuffer()[ p->indexList[ j + 2 ] ].tPos;
|
|
- Vec3< float > normal = ( b - a ).crossProduct( c - a ).normalize();
|
|
|
|
- float t = ( a * normal - point * normal ) / ( dir * normal );
|
|
|
|
|
|
+ Vec3< float > normal = (b - a).crossProduct( c - a ).normalize();
|
|
|
|
+ float t = (a * normal - point * normal) / (dir * normal);
|
|
Vec3< float > hit = point + dir * t;
|
|
Vec3< float > hit = point + dir * t;
|
|
- float a0 = ( a - b ).crossProduct( a - c ).getLength() / 2;
|
|
|
|
- float a1 = ( b - hit ).crossProduct( c - hit ).getLength() / 2 / a0;
|
|
|
|
- float a2 = ( c - hit ).crossProduct( a - hit ).getLength() / 2 / a0;
|
|
|
|
- float a3 = ( a - hit ).crossProduct( b - hit ).getLength() / 2 / a0;
|
|
|
|
|
|
+ float a0 = (a - b).crossProduct( a - c ).getLength() / 2;
|
|
|
|
+ float a1 = (b - hit).crossProduct( c - hit ).getLength() / 2 / a0;
|
|
|
|
+ float a2 = (c - hit).crossProduct( a - hit ).getLength() / 2 / a0;
|
|
|
|
+ float a3 = (a - hit).crossProduct( b - hit ).getLength() / 2 / a0;
|
|
Vertex ht = at * a1 + bt * a2 + ct * a3;
|
|
Vertex ht = at * a1 + bt * a2 + ct * a3;
|
|
- Bild *tex = textur->zPolygonTextur( index )->zBild();
|
|
|
|
|
|
+ Bild* tex = textur->zPolygonTextur( index )->zBild();
|
|
if( ht.x >= 0 && ht.y >= 0 && ht.x <= 1 && ht.y <= 1 )
|
|
if( ht.x >= 0 && ht.y >= 0 && ht.x <= 1 && ht.y <= 1 )
|
|
- return tex->getPixel( (int)( ht.x * ( (float)tex->getBreite() - 1.f ) + 0.5f ), (int)( ht.y * ( (float)tex->getHeight() - 1.f ) + 0.5f ) );
|
|
|
|
|
|
+ return tex->getPixel( (int)(ht.x * ((float)tex->getBreite() - 1.f) + 0.5f), (int)(ht.y * ((float)tex->getHeight() - 1.f) + 0.5f) );
|
|
return 0xFF000000;
|
|
return 0xFF000000;
|
|
}
|
|
}
|
|
pId--;
|
|
pId--;
|
|
@@ -895,7 +895,7 @@ int Model3D::getVertexAnzahl() const
|
|
}
|
|
}
|
|
|
|
|
|
// Gibt einen Buffer mit allen Vertecies des Models zurück
|
|
// Gibt einen Buffer mit allen Vertecies des Models zurück
|
|
-const Vertex3D *Model3D::zVertexBuffer() const
|
|
|
|
|
|
+const Vertex3D* Model3D::zVertexBuffer() const
|
|
{
|
|
{
|
|
return model ? model->zVertexBuffer() : 0;
|
|
return model ? model->zVertexBuffer() : 0;
|
|
}
|
|
}
|