Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9147 in orxonox.OLD for branches/terrain/src/lib/graphics/importer


Ignore:
Timestamp:
Jul 4, 2006, 3:45:43 PM (18 years ago)
Author:
ponder
Message:

To rid of the triple and plane struct in types.h. now using the generic ones

Location:
branches/terrain/src/lib/graphics/importer
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • branches/terrain/src/lib/graphics/importer/md3/md3_animation_cfg.cc

    r8724 r9147  
    8787
    8888    // parse file
    89     while( (read = getline(&cLine, &len, pFile)) != -1) { /*( !this->dataStream.eof()) {*/
     89        /*
     90    while( (read = getline(&cLine, &len, pFile)) != -1) {
     91                // ( !this->dataStream.eof()) {
    9092      std::string line(cLine);
    9193
    … …  
    176178        }
    177179      }
    178     }
     180    }*/
    179181  }
    180182

  • branches/terrain/src/lib/graphics/importer/terrain/frustum.h

    r9140 r9147  
    1515#ifndef _FRUSTUM_H
    1616#define _FRUSTUM_H
     17#include "plane.h"
     18#include "vector.h"
    1719#include "types.h"
    1820#include "glincl.h"
    … …  
    7173
    7274                                // is the positive vertex outside?
    73                                 if ( planes[i].distance( _box.vertexP( planes[i].n ) ) < 0 )
     75                                if ( planes[i].distancePoint( _box.vertexP( planes[i].n ) ) < 0 )
    7476                                        return OUTSIDE;
    7577                                // is the negative vertex outside?     
    76                                 else if ( planes[i].distance( _box.vertexN( planes[i].n ) ) < 0 )
     78                                else if ( planes[i].distancePoint( _box.vertexN( planes[i].n ) ) < 0 )
    7779                                        result = INTERSECT;
    7880                        }
    … …  
    8082                }
    8183               
    82                 inline int pointInFrustum( const Triple& _point)
     84                inline int pointInFrustum( const Vector& _point)
    8385                {
    8486                        int result = INSIDE;
    8587                        for(int i=0; i < 6; i++) {
    86                                 if (planes[i].distance( _point ) < 0)
     88                                if (planes[i].distancePoint( _point ) < 0)
    8789                                        return OUTSIDE;
    8890                        }
    … …  
    9193               
    9294                inline Plane getPlane( int _plane ) { return planes[_plane]; }
     95               
    9396                inline void setFrustum( float *_m )
    9497                {
    95                         planes[NEAR].setCoefficients( m(2,0) + m(3,0),
    96                                                                                   m(2,1) + m(3,1),
    97                                                                                   m(2,2) + m(3,2),
    98                                                                               m(2,3) + m(3,3));
    99                         planes[FAR].setCoefficients( -m(2,0) + m(3,0),
    100                                                                              -m(2,1) + m(3,1),
    101                                                                              -m(2,2) + m(3,2),
    102                                                                              -m(2,3) + m(3,3));
    103                         planes[BOTTOM].setCoefficients( m(1,0) + m(3,0),
    104                                                                                         m(1,1) + m(3,1),
    105                                                                                         m(1,2) + m(3,2),
    106                                                                                         m(1,3) + m(3,3));
    107                         planes[TOP].setCoefficients(  -m(1,0) + m(3,0),
    108                                                                           -m(1,1) + m(3,1),
    109                                                                           -m(1,2) + m(3,2),
    110                                                                           -m(1,3) + m(3,3));
    111                         planes[LEFT].setCoefficients(  m(0,0) + m(3,0),
    112                                                                            m(0,1) + m(3,1),
    113                                                                            m(0,2) + m(3,2),
    114                                                                            m(0,3) + m(3,3));
    115                         planes[RIGHT].setCoefficients(-m(0,0) + m(3,0),
    116                                                                           -m(0,1) + m(3,1),
    117                                                                           -m(0,2) + m(3,2),
    118                                                                           -m(0,3) + m(3,3));
     98                        planes[NEAR] =  Plane( Vector(
     99                                m(2,0) + m(3,0),
     100                                m(2,1) + m(3,1),
     101                                m(2,2) + m(3,2) ),
     102                                m(2,3) + m(3,3) );
     103                               
     104                        planes[FAR] = Plane( Vector(
     105                                -m(2,0) + m(3,0),
     106                                -m(2,1) + m(3,1),
     107                                -m(2,2) + m(3,2) ),
     108                                -m(2,3) + m(3,3) );
     109                                                                       
     110                        planes[BOTTOM] = Plane( Vector(
     111                                m(1,0) + m(3,0),
     112                                m(1,1) + m(3,1),
     113                                m(1,2) + m(3,2) ),
     114                                m(1,3) + m(3,3) );
     115                        planes[TOP] = Plane( Vector( 
     116                                -m(1,0) + m(3,0),
     117                                -m(1,1) + m(3,1),
     118                                -m(1,2) + m(3,2) ),
     119                                -m(1,3) + m(3,3) );
     120                        planes[LEFT] = Plane( Vector( 
     121                                m(0,0) + m(3,0),
     122                                m(0,1) + m(3,1),
     123                                m(0,2) + m(3,2) ),
     124                                m(0,3) + m(3,3) );
     125                        planes[RIGHT] =  Plane( Vector(
     126                                -m(0,0) + m(3,0),
     127                                -m(0,1) + m(3,1),
     128                                -m(0,2) + m(3,2) ),
     129                                -m(0,3) + m(3,3) );
    119130                                                       
    120                         if ( planes[NEAR].d +planes[FAR].d  > MAX_CLIP_DISTANCE ) {
    121                                 planes[FAR].d = -planes[NEAR].d+MAX_CLIP_DISTANCE;
     131                        if ( planes[NEAR].k +planes[FAR].k  > MAX_CLIP_DISTANCE ) {
     132                                planes[FAR].k = -planes[NEAR].k+MAX_CLIP_DISTANCE;
    122133                        }
    123134                }

  • branches/terrain/src/lib/graphics/importer/terrain/terrain.cc

    r9140 r9147  
    9797        pTerrainPage newPage = new TerrainPage( const_cast<Terrain*>( this ), _xOffset, _zOffset );
    9898        newPage->setScale( scale );     
    99         newPage->setPosition( Triple( scale.x*_xOffset, 0.0f, scale.z*_zOffset ) );
     99        newPage->setPosition( Vector( scale.x*_xOffset, 0.0f, scale.z*_zOffset ) );
    100100        newPage->calculateErrors();
    101101        return newPage;
    … …  
    248248        //Due to some reason, the OpenGL implementors chose the plane equation
    249249        //to an array of doubles. So we will make them happy.
    250         double farPlane[] = { far.n.x, far.n.y, far.n.z, far.d };
     250        double farPlane[] = { far.n.x, far.n.y, far.n.z, far.k };
    251251        glEnable( GL_CLIP_PLANE0 );
    252252        glClipPlane( GL_CLIP_PLANE0, farPlane );
    … …  
    419419}
    420420
    421 void Terrain::getAltitude( Triple& _alt, Triple& _normal )
     421void Terrain::getAltitude( Vector& _alt, Vector& _normal )
    422422{
    423423        float xScaled = _alt.x / scale.x, zScaled = _alt.z / scale.z;

  • branches/terrain/src/lib/graphics/importer/terrain/terrain.h

    r9140 r9147  
    2121#include "buffer_broker.h"
    2222#endif
    23 #include "types.h"
     23
     24#include "vector.h"
    2425#include "terrain_page.h"
    2526#include "terrain_quad.h"
    … …  
    3031#include "frustum.h"
    3132
     33class Texture;
    3234class Terrain;
    3335typedef Terrain *pTerrain;
    … …  
    5355
    5456       
    55                 inline void setCameraPosition( const Triple& _cameraPosition )
     57                inline void setCameraPosition( const Vector& _cameraPosition )
    5658                {
    5759                        cameraPosition = _cameraPosition;
    5860                }
    5961               
    60                 inline const Triple& getCameraPosition() const
     62                inline const Vector& getCameraPosition() const
    6163                {
    6264                        return cameraPosition;
    6365                }
    6466       
    65                 void getAltitude( Triple& _alt, Triple& _normal );
     67                void getAltitude( Vector& _alt, Vector& _normal );
    6668               
    6769                inline void setLightmap( Texture *_lightmap )
    … …  
    8688                        current = 0;
    8789                        activePages = NULL;
    88                         scale  = Triple( 1.0f, 3.0f, 1.0f );
     90                        scale  = Vector( 1.0f, 3.0f, 1.0f );
    8991                        frustum = new Frustum();
    9092                        activatedCount = deactivatedCount = 0;
    … …  
    114116                void draw( );
    115117
    116                 void setPageSize( const Triple& _page ) { }
     118                void setPageSize( const Vector& _page ) { }
    117119               
    118120                void build();
    … …  
    146148                }
    147149               
    148                 inline const Triple getScale() const { return scale; }
     150                inline const Vector getScale() const { return scale; }
    149151               
    150152                inline int getPageSize() const
    … …  
    159161                }
    160162               
    161                 inline void setScale( const Triple& _scale )
     163                inline void setScale( const Vector& _scale )
    162164                { scale = _scale; }
    163165#ifdef USE_VBO
    … …  
    197199                Texture                                         *lightmap;
    198200                Heightfield                                     heightfield;
    199                 Triple                                          scale;
     201                Vector                                          scale;
    200202                int                                             pagesX,
    201203                                                                        pagesZ;
    … …  
    213215                std::vector<BufferInfo>         buffers;                       
    214216                       
    215                 Triple                                          cameraPosition;
     217                Vector                                          cameraPosition;
    216218                pFrustum                                        frustum;
    217219                pTerrainPage                            activePages;

  • branches/terrain/src/lib/graphics/importer/terrain/terrain_page.cc

    r9140 r9147  
    4646                layerVisibility[i] = LV_NO;     
    4747               
    48         position = Triple( scale.x*_xOffset,
     48        position = Vector( scale.x*_xOffset,
    4949                0.0f, scale.z*_zOffset );
    5050        isVisible = false;
    … …  
    129129{
    130130        wantedLOD = -1;
    131         Triple cam( owner->getCameraPosition() );
     131        Vector cam( owner->getCameraPosition() );
    132132       
    133133        for ( int i = TerrainPage::MAX_LODS-1; i >= 0; --i ) {
    134                 Triple distance( cam.x-errors[i].correct.x,
     134                Vector distance( cam.x-errors[i].correct.x,
    135135                                                 cam.y-errors[i].correct.y,
    136136                                                 cam.z-errors[i].correct.z );
    137137               
    138                 float d = distance.length();
     138                float d = distance.len();
    139139               
    140140                float err =  errors[i].diff / d ;
    … …  
    230230        float alt = 0.0f;
    231231       
    232         Triple  min( xOffset*scale.x ,0.0f, zOffset*scale.z ),
     232        Vector  min( xOffset*scale.x ,0.0f, zOffset*scale.z ),
    233233                        max( (xOffset+1)*scale.x, 0.0f, (zOffset+1)*scale.z);
    234234       
    … …  
    774774}
    775775
    776 void TerrainPage::getVertex( int _x, int _z, Triple& _vertex ) const
     776void TerrainPage::getVertex( int _x, int _z, Vector& _vertex ) const
    777777{
    778778        _vertex.x = position.x+scale.x*_x/

  • branches/terrain/src/lib/graphics/importer/terrain/terrain_page.h

    r9140 r9147  
    2828struct Vertex {
    2929        TexCoord        t;     
    30         Triple          p;
     30        Vector          p;
    3131};
    3232
    … …  
    3434
    3535typedef struct {
    36         Triple  correct;
    37         Triple  real;
     36        Vector  correct;
     37        Vector  real;
    3838        float   diff;
    3939} LODError, *pLODError;
    … …  
    159159                 * Sets the position of the TerrainPage. Is this needed?
    160160                 */
    161                 inline void setPosition( const Triple& _pos )
     161                inline void setPosition( const Vector& _pos )
    162162                {
    163163                        position.x = _pos.x;
    … …  
    250250                 * Fills _vertex with the vertex information at index.
    251251                 */
    252                 void getVertex( int _x, int _z, Triple& _vertex ) const;
     252                void getVertex( int _x, int _z, Vector& _vertex ) const;
    253253               
    254254                /**
    … …  
    288288                pTerrainPage                            previous;
    289289                LODError                                        *errors;
    290                 Triple                                          position;
     290                Vector                                          position;
    291291};
    292292

  • branches/terrain/src/lib/graphics/importer/terrain/terrain_quad.cc

    r9140 r9147  
    4747                exit( 0 );
    4848        }       
    49         Triple min = Triple( children[BL_CHILD]->getBounds().min() );
    50         Triple max = Triple( children[TR_CHILD]->getBounds().max() );
     49        Vector min = Vector( children[BL_CHILD]->getBounds().min() );
     50        Vector max = Vector( children[TR_CHILD]->getBounds().max() );
    5151        for ( int i = 1; i < 4; ++i ) {
    5252                pTerrainQuad child = children[i];

  • branches/terrain/src/lib/graphics/importer/terrain/terrain_quad.h

    r9140 r9147  
    6666                        return children[_child];
    6767                }
    68                 inline void setScale( Triple _scale )
     68                inline void setScale( Vector _scale )
    6969                {
    7070                        scale = _scale;
    … …  
    9494                int                             xOffset, zOffset;
    9595                int                             width,  height;
    96                 Triple                  scale;
     96                Vector                  scale;
    9797                pTerrainQuad    children[4];
    9898                ABox                    bounds;

  • branches/terrain/src/lib/graphics/importer/terrain/types.h

    r9140 r9147  
    2626#define SAVE_DELETE( _a ) if ( _a ) { delete _a; _a = NULL; }
    2727
    28 struct Triple
    29 {
    30   Triple( float _x, float _y, float _z )
    31   {
    32     x = _x; y = _y; z = _z;
    33   }
    34   Triple() { x = y = z = 0.0f; }
    35   inline float length() const
    36     { return sqrt( x*x+y*y+z*z ); }
    37   float x, y, z;
    38 };
    39 
    4028struct TexCoord
    4129{
    … …  
    5442{
    5543
    56   ABox( Triple _min, Triple _max)
     44  ABox( Vector _min, Vector _max)
    5745  {
    5846    corner = _min;
    … …  
    6452  ABox()
    6553  {
    66     corner = Triple( 0.0f, 0.0f, 0.0f );
     54    corner = Vector( 0.0f, 0.0f, 0.0f );
    6755    x = y = z = 0.0f;
    6856  }
    69   inline void set( const Triple& _min, const Triple& _max )
     57  inline void set( const Vector& _min, const Vector& _max )
    7058  {
    7159    setMin( _min ); setMax( _max );
    7260  }
    73   inline void setMax( const Triple& _max )
     61  inline void setMax( const Vector& _max )
    7462  {
    7563    x = _max.x-corner.x;
    … …  
    7765    z = _max.z-corner.z;
    7866  }
    79   inline void setMin( const Triple& _min )
     67  inline void setMin( const Vector& _min )
    8068  {
    8169    corner = _min;
    8270  }
    83   inline Triple vertexP( const Triple& _normal ) const
     71  inline Vector vertexP( const Vector& _normal ) const
    8472  {
    85     Triple res = corner;
     73    Vector res = corner;
    8674    if ( _normal.x > 0 )
    8775      res.x+= x;
    … …  
    9381    return res;
    9482  }
    95   inline Triple vertexN( const Triple& _normal ) const
     83  inline Vector vertexN( const Vector& _normal ) const
    9684  {
    97     Triple res = corner;
     85    Vector res = corner;
    9886    if ( _normal.x < 0 )
    9987      res.x+= x;
    … …  
    10694
    10795  }
    108 inline Triple min() const { return Triple(corner); }
    109   inline Triple max() const { return Triple( corner.x+x, corner.y+y, corner.z+z ); }
    110   Triple corner;
     96inline Vector min() const { return Vector(corner); }
     97  inline Vector max() const { return Vector( corner.x+x, corner.y+y, corner.z+z ); }
     98  Vector corner;
    11199  float x, y, z;
    112100
    … …  
    115103// struct Plane
    116104// {
    117 //   Plane() { n = Triple( 0.0f, 1.0f, 0.0f ); d = 0.0f; }
     105//   Plane() { n = Vector( 0.0f, 1.0f, 0.0f ); d = 0.0f; }
    118106//   inline void setCoefficients( float _nx, float _ny, float _nz, float _d )
    119107//   {
    120 //     n = Triple( _nx, _ny, _nz );
     108//     n = Vector( _nx, _ny, _nz );
    121109//     float l = n.length();
    122110//     n.x /= l; n.y/=l; n.z/=l;
    123111//     d = _d/l;
    124112//   }
    125 //   inline float distance( const Triple& _point ) const
     113//   inline float distance( const Vector& _point ) const
    126114//   {
    127115//     return _point.x*n.x+_point.y*n.y+_point.z*n.z+d;
    128116//   }
    129 //   Triple n;
     117//   Vector n;
    130118//   float d;
    131119// };
Note: See TracChangeset for help on using the changeset viewer.