Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 9415 in orxonox.OLD for branches


Ignore:
Timestamp:
Jul 24, 2006, 12:59:44 PM (18 years ago)
Author:
bensch
Message:

some newlines

Location:
branches/terrain/src/lib
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r9414 r9415  
    11/*
    22        orxonox - the future of 3D-vertical-scrollers
    3  
     3
    44        Copyright (C) 2006 orx
    5  
     5
    66        This program is free software; you can redistribute it and/or modify
    77        it under the terms of the GNU General Public License as published by
    88        the Free Software Foundation; either version 2, or (at your option)
    99        any later version.
    10  
     10
    1111        ### File Specific:
    1212        main programmer: Marco Biasini
    13  
     13
    1414 */
    1515#ifndef _FRUSTUM_H
    … …  
    3131        }\
    3232        while ( 0 )
    33        
    34 /** 
     33
     34/**
    3535 * Code borrowed from Lighthouse 3D. Its a very good tutorial on culling.
    3636 */
    … …  
    4040
    4141        public:
    42                
     42
    4343                enum { NEAR = 0 , FAR = 1, TOP = 2, BOTTOM = 3, LEFT = 4, RIGHT = 5 };
    44                 enum { OUTSIDE, INTERSECT, INSIDE };           
    45                
     44                enum { OUTSIDE, INTERSECT, INSIDE };
     45
    4646                Frustum()
    4747                {
    … …  
    6565                        setFrustum( combined );
    6666                }
    67                
     67
    6868                inline int boxInFrustum( const ABox& _box )
    6969                {
    … …  
    7575                                if ( planes[i].distancePoint( _box.vertexP( planes[i].n ) ) < 0 )
    7676                                        return OUTSIDE;
    77                                 // is the negative vertex outside?     
     77                                // is the negative vertex outside?
    7878                                else if ( planes[i].distancePoint( _box.vertexN( planes[i].n ) ) < 0 )
    7979                                        result = INTERSECT;
    … …  
    8181                        return result;
    8282                }
    83                
     83
    8484                inline int pointInFrustum( const Vector& _point)
    8585                {
    … …  
    8989                                        return OUTSIDE;
    9090                        }
    91                         return result;         
     91                        return result;
    9292                }
    93                
     93
    9494                inline Plane getPlane( int _plane ) { return planes[_plane]; }
    95                
     95
    9696                inline void setFrustum( float *_m )
    9797                {
    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) ), 
     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) ),
    102102                                m(2,3) + m(3,3) );
    103                                
    104                         planes[FAR] = Plane( Vector( 
     103
     104                        planes[FAR] = Plane( Vector(
    105105                                -m(2,0) + m(3,0),
    106106                                -m(2,1) + m(3,1),
    107107                                -m(2,2) + m(3,2) ),
    108108                                -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) ), 
     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) ),
    114114                                m(1,3) + m(3,3) );
    115                         planes[TOP] = Plane( Vector( 
     115                        planes[TOP] = Plane( Vector(
    116116                                -m(1,0) + m(3,0),
    117117                                -m(1,1) + m(3,1),
    118118                                -m(1,2) + m(3,2) ),
    119119                                -m(1,3) + m(3,3) );
    120                         planes[LEFT] = Plane( Vector( 
     120                        planes[LEFT] = Plane( Vector(
    121121                                m(0,0) + m(3,0),
    122122                                m(0,1) + m(3,1),
    123123                                m(0,2) + m(3,2) ),
    124124                                m(0,3) + m(3,3) );
    125                         planes[RIGHT] =  Plane( Vector( 
     125                        planes[RIGHT] =  Plane( Vector(
    126126                                -m(0,0) + m(3,0),
    127127                                -m(0,1) + m(3,1),
    128128                                -m(0,2) + m(3,2) ),
    129129                                -m(0,3) + m(3,3) );
    130                                                        
     130
    131131                        if ( planes[NEAR].k +planes[FAR].k  > MAX_CLIP_DISTANCE ) {
    132132                                planes[FAR].k = -planes[NEAR].k+MAX_CLIP_DISTANCE;
    133133                        }
    134134                }
    135                
     135
    136136        protected:
    137137                Plane           *planes;

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

    r9414 r9415  
    11/*
    22        orxonox - the future of 3D-vertical-scrollers
    3  
     3
    44        Copyright (C) 2006 orx
    5  
     5
    66        This program is free software; you can redistribute it and/or modify
    77        it under the terms of the GNU General Public License as published by
    88        the Free Software Foundation; either version 2, or (at your option)
    99        any later version.
    10  
     10
    1111        ### File Specific:
    1212        main-programmer: Marco Biasini
    13  
     13
    1414 */
    1515#include "terrain_page.h"
    … …  
    2626        }\
    2727        while ( 0 )
    28        
     28
    2929TerrainPage::~TerrainPage( )
    30 { 
     30{
    3131        SAVE_DELETE_ARRAY( indices );
    3232        SAVE_DELETE_ARRAY( vertices );
    33         SAVE_DELETE_ARRAY( indexHash );         
    34         SAVE_DELETE_ARRAY( errors );   
     33        SAVE_DELETE_ARRAY( indexHash );
     34        SAVE_DELETE_ARRAY( errors );
    3535}
    3636
    … …  
    4141        numVertices = numIndices = 0;
    4242        errors = new LODError[TerrainPage::MAX_LODS];
    43         vertices = NULL; indices = NULL; 
     43        vertices = NULL; indices = NULL;
    4444        left = top = bottom = right = NULL;
    4545        for ( int i = 0; i < 8; ++i )
    46                 layerVisibility[i] = LV_NO;     
    47                
    48         position = Vector( scale.x*_xOffset, 
     46                layerVisibility[i] = LV_NO;
     47
     48        position = Vector( scale.x*_xOffset,
    4949                0.0f, scale.z*_zOffset );
    5050        isVisible = false;
    5151        next = NULL;
    5252        active = false;
    53         previous = NULL; 
     53        previous = NULL;
    5454        currentLOD = -1; wantedLOD = -1;
    5555        hasfull = false;
    … …  
    5858}
    5959
    60 void TerrainPage::tesselateRow( int _z, int _xStride, int _zStride, 
     60void TerrainPage::tesselateRow( int _z, int _xStride, int _zStride,
    6161        bool _adaptLeft, bool _adaptRight )
    6262{
    63        
    64         int xStart = 0, xEnd = owner->getPageSize();   
     63
     64        int xStart = 0, xEnd = owner->getPageSize();
    6565        int halfStride = _zStride >> 1;
    6666        assert( _xStride > 0 );         assert( _zStride > 0 );
    … …  
    7070        }
    7171        if ( _adaptLeft ) {
    72                 assert( halfStride > 0 );               
     72                assert( halfStride > 0 );
    7373                addIndex( getIndex( 0, _z ) );
    7474                addIndex( getIndex( 0, _z+halfStride ) );
    … …  
    7979                xStart = _xStride;
    8080        }
    81        
     81
    8282        if ( _adaptRight )
    8383                xEnd-=_xStride;
    84                
     84
    8585        for ( int x = xStart; x < xEnd; x+=_xStride ) {
    8686                addIndex( getIndex( x, _z) );
    8787                addIndex( getIndex( x, _z+_zStride ) );
    8888        }
    89        
     89
    9090        int w = owner->getPageSize()-1;
    91        
     91
    9292        if ( _adaptRight ) {
    93                 assert( halfStride > 0 );               
     93                assert( halfStride > 0 );
    9494                addIndex( getIndex( xEnd-1, _z ) );
    9595                addAgain();
    … …  
    106106{
    107107        _adapt[0] = _adapt[1] = _adapt[2] = _adapt[3] = false;
    108        
     108
    109109        if ( left  && left->isActive() ) {
    110110                _adapt[TP_LEFT] = ( wantedLOD - left->getWantedLOD() ) > 0;
    111                 assert( std::abs( wantedLOD - left->wantedLOD ) < 2 );         
    112         }       
     111                assert( std::abs( wantedLOD - left->wantedLOD ) < 2 );
     112        }
    113113        if ( right && right->isActive() ) {
    114114                _adapt[TP_RIGHT] = ( wantedLOD - right->getWantedLOD() ) > 0;
    115                 assert( std::abs( wantedLOD - right->wantedLOD ) < 2 );         
    116         }       
    117                
     115                assert( std::abs( wantedLOD - right->wantedLOD ) < 2 );
     116        }
     117
    118118        if ( top && top->isActive() ) {
    119                 _adapt[TP_TOP] = ( wantedLOD - top->getWantedLOD() ) > 0;                               
    120                 assert( std::abs( wantedLOD - top->wantedLOD ) < 2 );           
    121         }       
     119                _adapt[TP_TOP] = ( wantedLOD - top->getWantedLOD() ) > 0;
     120                assert( std::abs( wantedLOD - top->wantedLOD ) < 2 );
     121        }
    122122        if ( bottom && bottom->isActive() ) {
    123                 _adapt[TP_BOTTOM] = ( wantedLOD - bottom->getWantedLOD() ) > 0;         
     123                _adapt[TP_BOTTOM] = ( wantedLOD - bottom->getWantedLOD() ) > 0;
    124124                assert( std::abs( wantedLOD - bottom->wantedLOD ) < 2 );
    125         }       
     125        }
    126126}
    127127
    … …  
    130130        wantedLOD = -1;
    131131        Vector cam( owner->getCameraPosition() );
    132        
     132
    133133        for ( int i = TerrainPage::MAX_LODS-1; i >= 0; --i ) {
    134134                Vector distance( cam.x-errors[i].correct.x,
    135135                                                 cam.y-errors[i].correct.y,
    136136                                                 cam.z-errors[i].correct.z );
    137                
     137
    138138                float d = distance.len();
    139                
     139
    140140                float err =  errors[i].diff / d ;
    141                
     141
    142142                if ( err*scale.y < owner->getDetail() ) {
    143143                        wantedLOD = i;
    144144                        break;
    145                 }       
     145                }
    146146        }
    147147        if ( wantedLOD < 0 ) {
    148148                wantedLOD = TerrainPage::MAX_LODS-1;
    149         }       
     149        }
    150150        return wantedLOD;
    151151}
    … …  
    153153void TerrainPage::activate()
    154154{
    155        
     155
    156156        pTerrainPage list = owner->getActiveList();
    157157        next = list;
    … …  
    164164{
    165165        pTerrainPage list = owner->getActiveList();
    166        
     166
    167167        if ( previous ) {
    168168                previous->next = next;
    … …  
    175175        next = NULL;
    176176        previous = NULL;
    177        
     177
    178178}
    179179
    … …  
    186186        {
    187187                int stride = 1 << _lod, x0, y0, xi, yi;
    188                 // Altough these four nested loops look very scary, they're not 
    189                 // that bad and require only about O(n^2). 
     188                // Altough these four nested loops look very scary, they're not
     189                // that bad and require only about O(n^2).
    190190                for( y0 = 0 ; y0 < size-stride; y0 += stride ) {
    191191                        for( x0 = 0; x0 < size-stride; x0 += stride ) {
    … …  
    197197                                                float   fx0 = ( float )xi/( float )stride, fx1 = 1.0f-fx0,
    198198                                                                fy0 = ( float )yi/( float )stride, fy1 = 1.0f-fy0;
    199                                                
     199
    200200                                                float   height00 = getAltitude( x0, y0 ),
    201201                                                                height10 = getAltitude( x0+stride,y0 ),
    202202                                                                height01 = getAltitude( x0,y0+stride ),
    203203                                                                height11 = getAltitude( x0+stride, y0+stride );
    204                                                
     204
    205205                                                float   paintHeight =   fx1*fy1 * height00 +
    206206                                                        fx0*fy1 * height10 +
    … …  
    208208                                                        fx0*fy0 * height11,
    209209                                                        correctHeight =  getAltitude( x, y );
    210                                                
     210
    211211                                                float   er = ( float )fabs( correctHeight - paintHeight );
    212                                                
     212
    213213                                                numErrors++;
    214214                                                sumError += er;
    … …  
    229229        int size = owner->getPageSize();
    230230        float alt = 0.0f;
    231        
    232         Vector  min( xOffset*scale.x ,0.0f, zOffset*scale.z ), 
     231
     232        Vector  min( xOffset*scale.x ,0.0f, zOffset*scale.z ),
    233233                        max( (xOffset+1)*scale.x, 0.0f, (zOffset+1)*scale.z);
    234        
     234
    235235        min.y = max.y = getAltitude( 0, 0 );
    236236        for ( int x = 0; x < size; ++x ) {
    … …  
    248248        assert( _x >= 0 && _x < 17 );
    249249        assert( _z >= 0 && _z < 17 );
    250         return position.y+scale.y*owner->getAltitude( 
    251                         _x+(owner->getPageSize()-1)*xOffset, 
     250        return position.y+scale.y*owner->getAltitude(
     251                        _x+(owner->getPageSize()-1)*xOffset,
    252252                        _z+(owner->getPageSize()-1)*zOffset );
    253253}
    … …  
    255255bool TerrainPage::needsRetesselation()
    256256{
    257        
     257
    258258        bool    leftChanged     = ( left && left->isActive() ) &&
    259259                                ( left->wantedLOD != left->currentLOD ),
    260                         rightChanged    = ( right && right->isActive() ) && 
     260                        rightChanged    = ( right && right->isActive() ) &&
    261261                                ( right->wantedLOD != right->currentLOD ),
    262                         topChanged              = ( top && top->isActive() ) && 
     262                        topChanged              = ( top && top->isActive() ) &&
    263263                                ( top->wantedLOD != currentLOD ),
    264                         bottomChanged   = ( bottom && bottom->isActive() ) && 
     264                        bottomChanged   = ( bottom && bottom->isActive() ) &&
    265265                                ( bottom->wantedLOD != bottom->currentLOD ),
    266266                        iChanged                =  wantedLOD != currentLOD;
    267                                
    268         return ( leftChanged || rightChanged || topChanged || bottomChanged || 
     267
     268        return ( leftChanged || rightChanged || topChanged || bottomChanged ||
    269269                forceTesselation || iChanged );
    270270}
    … …  
    275275        if ( needsRetesselation() ) {
    276276                tesselate( wantedLOD );
    277         }       
     277        }
    278278        currentLOD = wantedLOD;
    279        
    280         //Check if the page is a level four page. If yes, copy the vertex and index data into 
     279
     280        //Check if the page is a level four page. If yes, copy the vertex and index data into
    281281        //the shared level four page buffers.
    282282        if ( currentLOD == TerrainPage::MAX_LODS-1 ) {
    283                 owner->addLevelFourPage( numVertices, vertices, 
     283                owner->addLevelFourPage( numVertices, vertices,
    284284                        numIndices, indices );
    285285        }
    … …  
    287287}
    288288
    289 void TerrainPage::tesselateTopRow(  int _z, int _stride, 
     289void TerrainPage::tesselateTopRow(  int _z, int _stride,
    290290        bool _adaptLeft,  bool _adaptRight )
    291291{
    … …  
    293293        int xStart = 0, xEnd= owner->getPageSize()-1;
    294294        int size = xEnd;
    295         int z = xEnd-_stride ; 
     295        int z = xEnd-_stride ;
    296296        addAgain();
    297297        addIndex( getIndex( 0, z ) );
    … …  
    331331
    332332}
    333 void TerrainPage::tesselateBottomRow(  int _z,  int _stride, 
     333void TerrainPage::tesselateBottomRow(  int _z,  int _stride,
    334334        bool _adaptLeft,  bool _adaptRight  )
    335335{
    … …  
    380380        numIndices = numVertices = 0;
    381381        const int       halfStride = 8, stride = 16;
    382        
     382
    383383        enum { ADAPT_L = 1, ADAPT_R = 2, ADAPT_B = 4, ADAPT_T = 8,
    384                 ADAPT_LR = 3, ADAPT_LB = 5, ADAPT_LT = 9, ADAPT_RB = 6, 
    385                 ADAPT_RT = 10, ADAPT_BT = 12, ADAPT_LRB = 7, ADAPT_LBT = 13, ADAPT_LRT = 11, 
     384                ADAPT_LR = 3, ADAPT_LB = 5, ADAPT_LT = 9, ADAPT_RB = 6,
     385                ADAPT_RT = 10, ADAPT_BT = 12, ADAPT_LRB = 7, ADAPT_LBT = 13, ADAPT_LRT = 11,
    386386                ADAPT_RBT = 14, ADAPT_LRBT = 15, ADAPT_NONE = 0 };
    387                
    388         int                     code =  ( _adapt[TP_LEFT]       ? ADAPT_L : 0 ) | 
    389                                                 ( _adapt[TP_RIGHT]      ? ADAPT_R : 0 ) | 
    390                                                 ( _adapt[TP_BOTTOM] ? ADAPT_B : 0 ) | 
     387
     388        int                     code =  ( _adapt[TP_LEFT]       ? ADAPT_L : 0 ) |
     389                                                ( _adapt[TP_RIGHT]      ? ADAPT_R : 0 ) |
     390                                                ( _adapt[TP_BOTTOM] ? ADAPT_B : 0 ) |
    391391                                                ( _adapt[TP_TOP]        ? ADAPT_T : 0 );
    392392        switch( code ) {
    … …  
    397397                        addIndex( getIndex( stride, stride ) );
    398398                        break;
    399                        
     399
    400400                case ADAPT_L:
    401401                        addIndex( getIndex( 0, 0 ) );
    … …  
    406406                        addAgain( );
    407407                        break;
    408                
     408
    409409                case ADAPT_R:
    410410                        addIndex( getIndex( stride, stride ) );
    … …  
    556556{
    557557
    558         memset( indexHash, 0xffff, 
     558        memset( indexHash, 0xffff,
    559559                        sizeof(unsigned short)*Terrain::MAX_VERTICES );
    560        
     560
    561561        numVertices = 0; numIndices = 0;
    562        
     562
    563563        //Calculate the pace, based on the lod.
    564564        int stride = 1 << _lod;
    565                
     565
    566566        bool adapt[4];
    567567        determineBorderAdaption( adapt );
    … …  
    573573                        vbIdentifier = ibIdentifier = 0;
    574574                }
    575                 if ( !vertices ) 
    576                         vertices =  new Vertex[8]; 
     575                if ( !vertices )
     576                        vertices =  new Vertex[8];
    577577                if ( !indices )
    578578                        indices = new unsigned short[8];
    … …  
    585585                        if ( indices )
    586586                                delete[] indices;
    587                         vertices = NULL; indices = NULL;       
     587                        vertices = NULL; indices = NULL;
    588588                }
    589589                assert( vbIdentifier ); assert( ibIdentifier );
    … …  
    591591
    592592                // The call to glBufferDataARB with a null argument for data is to make things faster.
    593                 // Then calling call glMapBuffer() tells the driver that the previous 
    594                 // data aren’t valid. As a consequence, if the GPU is still working on them, there won’t 
    595                 // be a conflict because we invalidated these data. The function glMapBuffer() returns a 
    596                 // new pointer that we can use while the GPU is working on the previous set of data.. 
    597 
    598                 glBufferDataARB( GL_ARRAY_BUFFER_ARB, Terrain::MAX_VERTICES*sizeof( Vertex ), 
     593                // Then calling call glMapBuffer() tells the driver that the previous
     594                // data aren’t valid. As a consequence, if the GPU is still working on them, there won’t
     595                // be a conflict because we invalidated these data. The function glMapBuffer() returns a
     596                // new pointer that we can use while the GPU is working on the previous set of data..
     597
     598                glBufferDataARB( GL_ARRAY_BUFFER_ARB, Terrain::MAX_VERTICES*sizeof( Vertex ),
    599599                        NULL, GL_DYNAMIC_DRAW_ARB );
    600600
    601                 vertices = (Vertex*)glMapBufferARB( GL_ARRAY_BUFFER_ARB, 
     601                vertices = (Vertex*)glMapBufferARB( GL_ARRAY_BUFFER_ARB,
    602602                        GL_WRITE_ONLY_ARB );
    603603
    604604                glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, ibIdentifier );
    605605
    606                 glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 
    607                         Terrain::MAX_INDICES*sizeof( short ), NULL, GL_DYNAMIC_DRAW_ARB );     
    608 
    609                 indices = (unsigned short*)glMapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 
     606                glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB,
     607                        Terrain::MAX_INDICES*sizeof( short ), NULL, GL_DYNAMIC_DRAW_ARB );
     608
     609                indices = (unsigned short*)glMapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB,
    610610                        GL_WRITE_ONLY_ARB );
    611611
    612         }       
    613 
    614 #endif 
     612        }
     613
     614#endif
    615615
    616616        assert( indices );      assert( vertices );
    … …  
    619619                return;
    620620        }
    621        
     621
    622622        int zStart = 0, zEnd = owner->getPageSize()-stride;
    623        
     623
    624624        if ( adapt[TP_BOTTOM] ) {
    625625                tesselateBottomRow( 0, stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
    626626                zStart+= stride;
    627627        }
    628        
     628
    629629        if ( adapt[TP_TOP] )
    630630                zEnd-= stride;
    631                
     631
    632632        for ( int z = zStart; z < zEnd; z+=stride )
    633633                tesselateRow( z, stride, stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
    634        
     634
    635635
    636636        if ( adapt[TP_TOP] ) {
    637                 tesselateTopRow( owner->getPageSize()-stride-1, 
     637                tesselateTopRow( owner->getPageSize()-stride-1,
    638638                        stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
    639639        }
    640        
     640
    641641#ifdef USE_VBO
    642642        if ( vbIdentifier && ibIdentifier ) {
    … …  
    645645                glUnmapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB );
    646646                vertices = NULL;
    647         }       
     647        }
    648648#endif
    649649
    … …  
    653653void TerrainPage::show( )
    654654{
    655        
    656 #ifdef USE_VBO 
     655
     656#ifdef USE_VBO
    657657        //This is done later on...
    658658        //owner->getBufferBroker()->acquire( vbIdentifier, ibIdentifier );
    … …  
    662662        vertices = new Vertex[Terrain::MAX_VERTICES];
    663663        indices = new unsigned short[Terrain::MAX_INDICES];
    664 #endif 
     664#endif
    665665        vbIdentifier = 0; ibIdentifier = 0;
    666         indexHash = new unsigned short[Terrain::MAX_VERTICES]; 
     666        indexHash = new unsigned short[Terrain::MAX_VERTICES];
    667667        forceTesselation = true;
    668668        activate();
    … …  
    673673{
    674674#ifdef USE_VBO
    675         owner->getBufferBroker()->release( vbIdentifier, ibIdentifier );       
     675        owner->getBufferBroker()->release( vbIdentifier, ibIdentifier );
    676676#endif
    677677        SAVE_DELETE_ARRAY( vertices );
    … …  
    692692                glVertex3f( bounds.x, bounds.y, 0.0f );
    693693                glVertex3f( 0.0f, bounds.y, 0.0f );
    694                
     694
    695695                glVertex3f( 0.0f, 0.0f, bounds.z );
    696696                glVertex3f(  bounds.x, 0.0f, bounds.z );
    697697                glVertex3f( bounds.x, bounds.y, bounds.z );
    698                 glVertex3f( 0.0f, bounds.y, bounds.z );         
    699                
     698                glVertex3f( 0.0f, bounds.y, bounds.z );
     699
    700700                glVertex3f( 0.0f, 0.0f, 0.0 );
    701701                glVertex3f(  0.0, 0.0f, bounds.z );
    702702                glVertex3f( 0.0f, bounds.y, bounds.z );
    703                 glVertex3f( 0.0f, bounds.y, 0.0f );                             
    704                
     703                glVertex3f( 0.0f, bounds.y, 0.0f );
     704
    705705                glVertex3f( bounds.x, 0.0f, 0.0 );
    706706                glVertex3f(  bounds.x, 0.0f, bounds.z );
    707707                glVertex3f( bounds.x, bounds.y, bounds.z );
    708                 glVertex3f( bounds.x, bounds.y, 0.0f );                                         
     708                glVertex3f( bounds.x, bounds.y, 0.0f );
    709709        glEnd();
    710710        glPopMatrix();
    … …  
    716716        assert( glIsEnabled( GL_VERTEX_ARRAY ) );
    717717        assert( !glIsEnabled( GL_NORMAL_ARRAY ) );
    718        
     718
    719719        if ( currentLOD == TerrainPage::MAX_LODS-1 )
    720720                return;
    721                
     721
    722722        assert( isVisible ); assert( numIndices > 0 );
    723723        active = false;
    724         CHECK_GL_ERROR( "1" ); 
     724        CHECK_GL_ERROR( "1" );
    725725#ifdef USE_VBO
    726        
     726
    727727        glBindBufferARB( GL_ARRAY_BUFFER_ARB, vbIdentifier );
    728728        glClientActiveTextureARB( GL_TEXTURE0_ARB );
    729729        glInterleavedArrays( GL_T2F_V3F, 0, NULL );
    730        
     730
    731731        glClientActiveTextureARB( GL_TEXTURE1_ARB );
    732732        glInterleavedArrays( GL_T2F_V3F, 0, NULL );
    733        
    734         glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, ibIdentifier );   
    735        
    736         glDrawElements( GL_TRIANGLE_STRIP, numIndices, 
    737                                         GL_UNSIGNED_SHORT, NULL );     
    738 #else   
     733
     734        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, ibIdentifier );
     735
     736        glDrawElements( GL_TRIANGLE_STRIP, numIndices,
     737                                        GL_UNSIGNED_SHORT, NULL );
     738#else
    739739        glClientActiveTextureARB( GL_TEXTURE0_ARB );
    740740        glInterleavedArrays( GL_T2F_V3F, 0, vertices );
    741        
     741
    742742        glClientActiveTextureARB( GL_TEXTURE1_ARB );
    743743        glInterleavedArrays( GL_T2F_V3F, 0, vertices );
    744        
    745         glDrawElements( GL_TRIANGLE_STRIP, numIndices, 
    746                                         GL_UNSIGNED_SHORT, indices );   
     744
     745        glDrawElements( GL_TRIANGLE_STRIP, numIndices,
     746                                        GL_UNSIGNED_SHORT, indices );
    747747#endif
    748        
    749 
    750        
     748
     749
     750
    751751        if ( owner->debug() )
    752752                drawBox( );
    753                
    754         CHECK_GL_ERROR( "2" ); 
     753
     754        CHECK_GL_ERROR( "2" );
    755755}
    756756
    … …  
    768768}
    769769
    770 void TerrainPage::getCoord( int _x, int _z, TexCoord& _coord ) const 
    771 {
    772         owner->getCoord( _x+xOffset*(owner->getPageSize()-1 ), 
     770void TerrainPage::getCoord( int _x, int _z, TexCoord& _coord ) const
     771{
     772        owner->getCoord( _x+xOffset*(owner->getPageSize()-1 ),
    773773                                         _z+zOffset*(owner->getPageSize()-1 ), _coord );
    774774}
    … …  
    789789                if ( _layer )
    790790                        hasfull = true;
    791         }       
    792         layerVisibility[_layer] = _lv; 
     791        }
     792        layerVisibility[_layer] = _lv;
    793793}
    794794
    795795bool TerrainPage::hasMaterial( int _layer )
    796 { 
     796{
    797797        return ( layerVisibility[_layer] != LV_NO );
    798798}

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

    r9414 r9415  
    11/*
    22        orxonox - the future of 3D-vertical-scrollers
    3  
     3
    44        Copyright (C) 2006 orx
    5  
     5
    66        This program is free software; you can redistribute it and/or modify
    77        it under the terms of the GNU General Public License as published by
    88        the Free Software Foundation; either version 2, or (at your option)
    99        any later version.
    10  
     10
    1111        ### File Specific:
    1212        main programmer: Marco Biasini
    13  
     13
    1414 */
    1515
    … …  
    2727
    2828struct Vertex {
    29         TexCoord        t;     
     29        TexCoord        t;
    3030        Vector          p;
    3131};
    … …  
    4343                enum { TP_LEFT = 0, TP_RIGHT = 1, TP_BOTTOM = 2, TP_TOP = 3 };
    4444                const static int MAX_LODS                       = 5;
    45                
     45
    4646                /**
    4747                 * Creates a new terrain page with its lower left corner set
    … …  
    5252                 */
    5353                TerrainPage( Terrain *_owner, int _xOffset, int _zOffset );
    54                
     54
    5555                /**
    5656                 * This is used only internally for communication between the TerrainPage and
    … …  
    5858                 */
    5959                inline bool isActive() { return active; }
    60                
     60
    6161                virtual ~TerrainPage();
    6262                /**
    63                  * @brief Makes the terrain look as if it were created with the given level of 
     63                 * @brief Makes the terrain look as if it were created with the given level of
    6464                 * detail.
    6565                 */
    6666                void mimick( int _level ) {}
    67                
     67
    6868                /**
    6969                 * @brief Draws a box around the TerrainPage. For debugging purposes.
    7070                 */
    7171                void drawBox();
    72                
    73                 /** 
     72
     73                /**
    7474                 * @brief Calculates the smallest fitting axis aligned bounding box for this TerrainPage.
    7575                 */
    76                 virtual void calculateBounds();         
    77                
    78                
    79                 /**
    80                  * @brief Sets the visibility to _flag. If the visibility changed, the vertex and 
     76                virtual void calculateBounds();
     77
     78
     79                /**
     80                 * @brief Sets the visibility to _flag. If the visibility changed, the vertex and
    8181                 * index arrays are allocated or freed, respectively.
    8282                 */
    … …  
    8787                 */
    8888                void show( );
    89                
     89
    9090                /**
    9191                 * @brief Frees most of the memory for economomical reasons.
    9292                 */
    93                 void hide( ); 
    94                
     93                void hide( );
     94
    9595                /**
    9696                 * @brief Updates the tesselation if necessary.
    9797                 */
    9898                void updateTesselation( );
    99                
     99
    100100                /**
    101101                 * @return The current tesselation level.
    102102                 */
    103103                int getLOD() { return currentLOD; }
    104                
    105                 /**
    106                  * @return The curren tween factor. This is a floating point value  between 0.0f 
     104
     105                /**
     106                 * @return The curren tween factor. This is a floating point value  between 0.0f
    107107                 * and 1.0f
    108108                 */
    109109                float getTween() { return 0.0f; }
    110                
     110
    111111                /**
    112112                 * @brief Determines the new LOD which should be used by this terrain page based on
    113                  * the distance from the camera. 
     113                 * the distance from the camera.
    114114                 *
    115                  * No geometry is updated in this method. You need to call 
     115                 * No geometry is updated in this method. You need to call
    116116                 * updateTesselation() in order to see a change in geometry. This method is
    117                  * just a recommondation for the LOD. It might be invalid due to outer 
     117                 * just a recommondation for the LOD. It might be invalid due to outer
    118118                 * constraints.
    119119                 */
    120120                int chooseLOD();
    121                
     121
    122122                /**
    123123                 * If the terrain pages tesselation level changed between the last and the
    … …  
    127127                 */
    128128                bool isDirty() { return forceTesselation; }
    129                
     129
    130130                /**
    131131                 * @brief Calculates the maximal errors for every LOD.
    132132                 */
    133133                void calculateErrors();
    134                
     134
    135135                /**
    136136                 * @brief Calculates the error for the given LOD. We just need to know the "worst"
    … …  
    138138                 */
    139139                void calculateError( int _lod );
    140                
    141                
     140
     141
    142142                /**
    143143                 * Tests if the terrain page would cull against the viewing frustum.
    … …  
    150150                 * pages is at the border.
    151151                 */
    152                 inline void setNeighbors( pTerrainPage _left, pTerrainPage _right, 
     152                inline void setNeighbors( pTerrainPage _left, pTerrainPage _right,
    153153                        pTerrainPage _top, pTerrainPage _bottom )
    154154                {
    155155                        left = _left; right = _right; top = _top; bottom = _bottom;
    156156                }
    157                
     157
    158158                /**
    159159                 * Sets the position of the TerrainPage. Is this needed?
    … …  
    169169                pTerrainPage getRight() { return right; }
    170170                pTerrainPage getBottom() { return bottom; }
    171                 pTerrainPage getTop() { return top; }                                           
    172                
     171                pTerrainPage getTop() { return top; }
     172
    173173                /**
    174174                 *  Does what exactly what the name says and nothing more.
    175175                 */
    176176                void draw( );
    177                
     177
    178178                /**
    179179                 * @return the next active page
    … …  
    181181                inline pTerrainPage getNext() { return next; }
    182182                void setLayerVisibility( int _layer, LayerVisibility _lv );
    183                 bool hasMaterial( int _layer );         
     183                bool hasMaterial( int _layer );
    184184                /**
    185185                 * Returns the previous active page
    186186                 */
    187                 inline pTerrainPage getPrevious() { return previous; }                 
     187                inline pTerrainPage getPrevious() { return previous; }
    188188                inline int getCurrentLOD() { return currentLOD; }
    189189                /**
    … …  
    192192                 */
    193193                inline int getWantedLOD() { return wantedLOD; }
    194                
     194
    195195                /**
    196196                 * @brief Removes the page from the active page list.
    197197                 */
    198198                void deactivate();
    199                
    200                 /** 
     199
     200                /**
    201201                 * @brief Inserts the page into the active page list.
    202202                 */
    203                 void activate();               
     203                void activate();
    204204
    205205                inline void setWantedLOD( int _lod )
    … …  
    212212                                wantedLOD = _lod;
    213213                }
    214                                
     214
    215215        protected:
    216                
     216
    217217                /**
    218218                 * @brief Tesselates one row of the terrain page.
    … …  
    221221                 * @param _zStride              Defines the step-size vertically.
    222222                 * @param _adaptLeft    True if the left neighbor has a coarser
    223                  *                                              tesselation level.             
     223                 *                                              tesselation level.
    224224                 * @param _adaptRight   True if the right neighbor has a coarser
    225225                 *                                              tesselation level.
    … …  
    228228                void tesselateTopRow( int _z, int _stride, bool _adaptLeft, bool _adaptRight );
    229229                void tesselateBottomRow( int _z, int _stride, bool _adaptLeft, bool _adaptRight );
    230                 /** 
     230                /**
    231231                 * @brief Returns four boolean values in the oder
    232232                 */
    233233                void determineBorderAdaption( bool _adapt[] );
    234                
     234
    235235                /**
    236236                 * @brief Adds the given index to the index-array
    237237                 */
    238238                inline void addIndex( unsigned short _index );
    239                
     239
    240240                /**
    241241                 * @brief We programmers are very lazy :) This method just adds the last added index
    … …  
    243243                 */
    244244                inline void addAgain();
    245                
    246                
     245
     246
    247247                void getCoord( int _x, int _z, TexCoord& _coord) const;
    248                
    249                 /** 
     248
     249                /**
    250250                 * Fills _vertex with the vertex information at index.
    251251                 */
    252252                void getVertex( int _x, int _z, Vector& _vertex ) const;
    253                
     253
    254254                /**
    255255                 * Use this method to safely get a vertex at location ( _x, _z ). If it wasn't
    256                  * created before, this method does that for you. 
    257                  */                     
     256                 * created before, this method does that for you.
     257                 */
    258258                unsigned short getIndex( int _x, int _z );
    259259                void tesselateLevelFourPage( bool _adapt[] );
    … …  
    261261                * Generates the tesselation for the given level of detail.
    262262                */
    263                 void tesselate( int _lod );                     
     263                void tesselate( int _lod );
    264264
    265265                float getAltitude( int _x, int _z ) const;
    266                
     266
    267267                int                                                     currentLOD,
    268268                                                                        wantedLOD;
    269                 pTerrainPage                            left, 
     269                pTerrainPage                            left,
    270270                                                                        right,
    271271                                                                        top,
    … …  
    283283                GLuint                                          ibIdentifier,
    284284                                                                        vbIdentifier;
    285 #endif         
     285#endif
    286286                bool                                            isVisible;
    287287                pTerrainPage                            next;
    … …  
    313313}
    314314
    315 inline void TerrainPage::addAgain() 
    316 { 
    317         indices[numIndices] = indices[numIndices-1]; numIndices++;                             
     315inline void TerrainPage::addAgain()
     316{
     317        indices[numIndices] = indices[numIndices-1]; numIndices++;
    318318}
    319319

  • branches/terrain/src/lib/util/byte_order.h

    r9414 r9415  
    1515#else
    1616#define NATIVE_BYTEORDER BigEndian
    17 #endif 
     17#endif
    1818
    1919

  • branches/terrain/src/lib/util/filesys/binary_file.cc

    r9414 r9415  
    4646                                        delete chunk;
    4747                                        return NULL;
    48                                 }       
     48                                }
    4949                                break;
    5050                        default:
    … …  
    6464                        case 's':
    6565                                chunk->chunks[currChunk] = new DataSemantics();
    66                                 chunk->chunks[currChunk]->isTerminal = true;   
     66                                chunk->chunks[currChunk]->isTerminal = true;
    6767                                chunk->chunks[currChunk]->type = bytesize( *curr );
    68                                 chunk->chunks[currChunk]->totalSize = bytesize( *curr );                                               
     68                                chunk->chunks[currChunk]->totalSize = bytesize( *curr );
    6969                                currChunk++;
    7070                                break;
    … …  
    8989                                *cp = '\0';
    9090                                chunk->chunks[currChunk] = compileSemantics( tmp );
    91                                 currChunk++;                                   
     91                                currChunk++;
    9292                                break;
    9393                        case ')':
    … …  
    111111                                        delete[] tmp; delete chunk;
    112112                                        return NULL;
    113                                 }                               
     113                                }
    114114                                if ( currChunk ) {
    115115                                        chunk->chunks[currChunk-1]->quantifier = quantifier;
    116                                         chunk->chunks[currChunk-1]->totalSize*= quantifier;                                     
    117                                 }       
     116                                        chunk->chunks[currChunk-1]->totalSize*= quantifier;
     117                                }
    118118                                else {
    119119                                        printf( "Syntax error: Quantifier without a preceding type\n" );
    … …  
    141141                switch( _comp->type ) {
    142142                        case TT_INT:
    143                                 iptr = (int*)ptr;                       
     143                                iptr = (int*)ptr;
    144144                                for ( int i = 0; i < _comp->quantifier; ++i ) {
    145145                                        swap32( iptr );
    … …  
    152152                                        swap16( sptr );
    153153                                        sptr++;
    154                                 }                       
     154                                }
    155155                                break;
    156156                        case TT_BYTE:
    … …  
    163163                                convert_data( _comp->chunks[i], ptr );
    164164                                ptr+= _comp->chunks[i]->totalSize;
    165                         }                       
    166                 }
    167 
    168         }       
    169 }
    170 void BinaryFile::read( const char *_semantics, int _chunks, 
     165                        }
     166                }
     167
     168        }
     169}
     170void BinaryFile::read( const char *_semantics, int _chunks,
    171171        void* _buf, size_t& _bytesRead )
    172172{
    173         pDataSemantics comp = compileSemantics( _semantics );           
     173        pDataSemantics comp = compileSemantics( _semantics );
    174174        fread( _buf, comp->totalSize, _chunks, this->handle() );
    175175        if ( byteorder != NATIVE_BYTEORDER ) {
    176176                for ( int i = 0; i < _chunks; ++i ) {
    177177                        convert_data( comp, (char*)_buf+i*comp->totalSize );
    178                 }       
    179         }       
     178                }
     179        }
    180180        _bytesRead = comp->totalSize*_chunks;
    181         delete comp;   
    182 }
    183 void BinaryFile::read( const char *_semantics, 
     181        delete comp;
     182}
     183void BinaryFile::read( const char *_semantics,
    184184        void* _buf, size_t& _bytesRead )
    185185{
    186         pDataSemantics comp = compileSemantics( _semantics );           
     186        pDataSemantics comp = compileSemantics( _semantics );
    187187        fread( _buf, comp->totalSize, 1, this->handle() );
    188        
     188
    189189        if ( byteorder != NATIVE_BYTEORDER ) {
    190190                convert_data( comp, _buf );
    191         }       
    192         delete comp;           
    193 }
    194 
    195 void BinaryFile::write( const char *_semantics, 
     191        }
     192        delete comp;
     193}
     194
     195void BinaryFile::write( const char *_semantics,
    196196        void* _buf, size_t& _bytesWritten )
    197197{
    … …  
    199199        if ( byteorder != NATIVE_BYTEORDER ) {
    200200                convert_data( comp, _buf );
    201         }       
     201        }
    202202        _bytesWritten = comp->totalSize;
    203203        fwrite( _buf, comp->totalSize, 1, this->handle() );

  • branches/terrain/src/lib/util/filesys/binary_file.h

    r9414 r9415  
    2222        }
    2323
    24         ~DataSemantics() 
     24        ~DataSemantics()
    2525        {
    2626                delete[] chunks;
    2727        }
    28        
     28
    2929        int                     totalSize;
    3030        int                     quantifier;
    … …  
    3333        union {
    3434                int                             type;
    35                 DataSemantics   **chunks; 
    36         };     
     35                DataSemantics   **chunks;
     36        };
    3737};
    3838
    … …  
    4040
    4141class BinaryFile : public File {
    42         public:         
     42        public:
    4343                BinaryFile()
    4444                        :       File( "" ),
    4545                                byteorder( NATIVE_BYTEORDER )
    4646                { /* nothing to be done */ }
    47                
     47
    4848                BinaryFile( const std::string& _file )
    49                         :       File( _file ), 
     49                        :       File( _file ),
    5050                                byteorder( NATIVE_BYTEORDER )
    5151                { /* nothing to be done */ }
    5252
    5353                BinaryFile( const BinaryFile& _file )
    54                         :       File( _file.name() ), 
     54                        :       File( _file.name() ),
    5555                                byteorder( _file.getByteorder() )
    5656                { /* nothing to be done */ }
    57                
     57
    5858                /**
    5959                 * Reads a chunk of data based on the _semantics string. The string contains
    … …  
    7070                 */
    7171                void read( const char *_semantics, void* _buf, size_t& _bytesRead );
    72                
     72
    7373                /**
    7474                 * The same as the read above, but with the ability to read multiple
    75                  * chunks once. Very useful if you don't know how many chunks you're 
     75                 * chunks once. Very useful if you don't know how many chunks you're
    7676                 * going to read at compile time.
    7777                 */
    78                 void read( const char *_semantics, int _chunks, 
     78                void read( const char *_semantics, int _chunks,
    7979                        void* _buf, size_t& _bytesRead );
    8080                /**
    … …  
    9393                 * in the middle of reading a file. You're totally on your own.
    9494                 */
    95                 inline void setByteorder( ByteOrder _order ) 
     95                inline void setByteorder( ByteOrder _order )
    9696                { byteorder = _order; }
    97                
     97
    9898                /**
    9999                 * Returns the file's byte-order.
    … …  
    101101                inline ByteOrder getByteorder() const
    102102                { return byteorder; }
    103                
     103
    104104        private:
    105                 pDataSemantics compileSemantics( const char *_semantics );     
     105                pDataSemantics compileSemantics( const char *_semantics );
    106106                ByteOrder               byteorder;
    107107};
Note: See TracChangeset for help on using the changeset viewer.