Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/terrain.older/src/lib/graphics/importer/terrain/terrain_page.cc

Last change on this file was 9147, checked in by ponder, 18 years ago

To rid of the triple and plane struct in types.h. now using the generic ones
File size: 21.2 KB
Line 
1/*
2        orxonox - the future of 3D-vertical-scrollers
3 
4        Copyright (C) 2006 orx
5 
6        This program is free software; you can redistribute it and/or modify
7        it under the terms of the GNU General Public License as published by
8        the Free Software Foundation; either version 2, or (at your option)
9        any later version.
10 
11        ### File Specific:
12        main-programmer: Marco Biasini
13 
14 */
15#include "terrain_page.h"
16#include "terrain.h"
17#include "glincl.h"
18#include <stdio.h>
19#include <math.h>
20#define USE_VBO
21
22#define CHECK_GL_ERROR( _d ) do { \
23        GLenum __err = glGetError(); \
24        if ( __err != GL_NO_ERROR ) \
25                printf( "check%s: %s\n", _d, (char*)gluErrorString( __err ) );\
26        }\
27        while ( 0 )
28       
29TerrainPage::~TerrainPage( )
30{ 
31        SAVE_DELETE_ARRAY( indices );
32        SAVE_DELETE_ARRAY( vertices );
33        SAVE_DELETE_ARRAY( indexHash );         
34        SAVE_DELETE_ARRAY( errors );   
35}
36
37TerrainPage::TerrainPage( Terrain *_owner, int _xOffset, int _zOffset )
38: TerrainQuad( _owner, _xOffset, _zOffset )
39{
40        scale = owner->getScale();
41        numVertices = numIndices = 0;
42        errors = new LODError[TerrainPage::MAX_LODS];
43        vertices = NULL; indices = NULL; 
44        left = top = bottom = right = NULL;
45        for ( int i = 0; i < 8; ++i )
46                layerVisibility[i] = LV_NO;     
47               
48        position = Vector( scale.x*_xOffset, 
49                0.0f, scale.z*_zOffset );
50        isVisible = false;
51        next = NULL;
52        active = false;
53        previous = NULL; 
54        currentLOD = -1; wantedLOD = -1;
55        hasfull = false;
56        forceTesselation = true;
57        vbIdentifier = 0; ibIdentifier = 0;
58}
59
60void TerrainPage::tesselateRow( int _z, int _xStride, int _zStride, 
61        bool _adaptLeft, bool _adaptRight )
62{
63       
64        int xStart = 0, xEnd = owner->getPageSize();   
65        int halfStride = _zStride >> 1;
66        assert( _xStride > 0 );         assert( _zStride > 0 );
67        if ( _z ) {
68                addAgain();
69                addIndex( getIndex( 0, _z ) );
70        }
71        if ( _adaptLeft ) {
72                assert( halfStride > 0 );               
73                addIndex( getIndex( 0, _z ) );
74                addIndex( getIndex( 0, _z+halfStride ) );
75                addIndex( getIndex( _xStride, _z ) );
76                addIndex( getIndex( 0, _z+_zStride ) );
77                addIndex( getIndex( _xStride, _z+_zStride ) );
78                addAgain();
79                xStart = _xStride;
80        }
81       
82        if ( _adaptRight )
83                xEnd-=_xStride;
84               
85        for ( int x = xStart; x < xEnd; x+=_xStride ) {
86                addIndex( getIndex( x, _z) );
87                addIndex( getIndex( x, _z+_zStride ) );
88        }
89       
90        int w = owner->getPageSize()-1;
91       
92        if ( _adaptRight ) {
93                assert( halfStride > 0 );               
94                addIndex( getIndex( xEnd-1, _z ) );
95                addAgain();
96                addIndex( getIndex( w, _z ) );
97                addIndex( getIndex( xEnd-1, _z+_zStride ) );
98                addIndex( getIndex( w, _z+halfStride ) );
99                addIndex( getIndex( w, _z+_zStride ) );
100        }
101}
102
103//TODO: Perform benchmark to measure if the isVisible test should be included
104//in this method.
105void TerrainPage::determineBorderAdaption( bool _adapt[] )
106{
107        _adapt[0] = _adapt[1] = _adapt[2] = _adapt[3] = false;
108       
109        if ( left  && left->isActive() ) {
110                _adapt[TP_LEFT] = ( wantedLOD - left->getWantedLOD() ) > 0;
111                assert( std::abs( wantedLOD - left->wantedLOD ) < 2 );         
112        }       
113        if ( right && right->isActive() ) {
114                _adapt[TP_RIGHT] = ( wantedLOD - right->getWantedLOD() ) > 0;
115                assert( std::abs( wantedLOD - right->wantedLOD ) < 2 );         
116        }       
117               
118        if ( top && top->isActive() ) {
119                _adapt[TP_TOP] = ( wantedLOD - top->getWantedLOD() ) > 0;                               
120                assert( std::abs( wantedLOD - top->wantedLOD ) < 2 );           
121        }       
122        if ( bottom && bottom->isActive() ) {
123                _adapt[TP_BOTTOM] = ( wantedLOD - bottom->getWantedLOD() ) > 0;         
124                assert( std::abs( wantedLOD - bottom->wantedLOD ) < 2 );
125        }       
126}
127
128int TerrainPage::chooseLOD()
129{
130        wantedLOD = -1;
131        Vector cam( owner->getCameraPosition() );
132       
133        for ( int i = TerrainPage::MAX_LODS-1; i >= 0; --i ) {
134                Vector distance( cam.x-errors[i].correct.x,
135                                                 cam.y-errors[i].correct.y,
136                                                 cam.z-errors[i].correct.z );
137               
138                float d = distance.len();
139               
140                float err =  errors[i].diff / d ;
141               
142                if ( err*scale.y < owner->getDetail() ) {
143                        wantedLOD = i;
144                        break;
145                }       
146        }
147        if ( wantedLOD < 0 ) {
148                wantedLOD = TerrainPage::MAX_LODS-1;
149        }       
150        return wantedLOD;
151}
152
153void TerrainPage::activate()
154{
155       
156        pTerrainPage list = owner->getActiveList();
157        next = list;
158        if ( list )
159                list->previous = this;
160        owner->setActiveList( this );
161}
162
163void TerrainPage::deactivate()
164{
165        pTerrainPage list = owner->getActiveList();
166       
167        if ( previous ) {
168                previous->next = next;
169        }
170        if ( next ) {
171                next->previous = previous;
172        }
173        if ( list == this )
174                owner->setActiveList( next );
175        next = NULL;
176        previous = NULL;
177       
178}
179
180void TerrainPage::calculateError( int _lod )
181{
182        float   sumError = 0.0f;
183        int             numErrors = 0;
184        int size = owner->getPageSize();
185        if( _lod!=0 )
186        {
187                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).
190                for( y0 = 0 ; y0 < size-stride; y0 += stride ) {
191                        for( x0 = 0; x0 < size-stride; x0 += stride ) {
192                                for( yi = 1; yi < stride; yi++ ) {
193                                        for( xi = 1; xi < stride; xi++ )
194                                        {
195                                                int     x = x0+xi,
196                                                y = y0+yi;
197                                                float   fx0 = ( float )xi/( float )stride, fx1 = 1.0f-fx0,
198                                                                fy0 = ( float )yi/( float )stride, fy1 = 1.0f-fy0;
199                                               
200                                                float   height00 = getAltitude( x0, y0 ),
201                                                                height10 = getAltitude( x0+stride,y0 ),
202                                                                height01 = getAltitude( x0,y0+stride ),
203                                                                height11 = getAltitude( x0+stride, y0+stride );
204                                               
205                                                float   paintHeight =   fx1*fy1 * height00 +
206                                                        fx0*fy1 * height10 +
207                                                        fx1*fy0 * height01 +
208                                                        fx0*fy0 * height11,
209                                                        correctHeight =  getAltitude( x, y );
210                                               
211                                                float   er = ( float )fabs( correctHeight - paintHeight );
212                                               
213                                                numErrors++;
214                                                sumError += er;
215                                        }
216                                }
217                        }
218                }
219                float error = sumError / numErrors;
220                getVertex(size/2, size/2, errors[_lod].correct);
221                errors[_lod].real = errors[_lod].correct;
222                errors[_lod].real.y += error;
223                errors[_lod].diff = error;
224        }
225}
226
227void TerrainPage::calculateBounds()
228{
229        int size = owner->getPageSize();
230        float alt = 0.0f;
231       
232        Vector  min( xOffset*scale.x ,0.0f, zOffset*scale.z ), 
233                        max( (xOffset+1)*scale.x, 0.0f, (zOffset+1)*scale.z);
234       
235        min.y = max.y = getAltitude( 0, 0 );
236        for ( int x = 0; x < size; ++x ) {
237                for ( int z = 0; z < size; ++z ) {
238                        alt = getAltitude( x, z );
239                        min.y = fmin( min.y, alt-1.0f );
240                        max.y = fmax( max.y, alt+1.0f );
241                }
242        }
243        bounds.set( min, max );
244}
245
246float TerrainPage::getAltitude( int _x, int _z ) const
247{
248        assert( _x >= 0 && _x < 17 );
249        assert( _z >= 0 && _z < 17 );
250        return position.y+scale.y*owner->getAltitude( 
251                        _x+(owner->getPageSize()-1)*xOffset, 
252                        _z+(owner->getPageSize()-1)*zOffset );
253}
254
255bool TerrainPage::needsRetesselation()
256{
257       
258        bool    leftChanged     = ( left && left->isActive() ) &&
259                                ( left->wantedLOD != left->currentLOD ),
260                        rightChanged    = ( right && right->isActive() ) && 
261                                ( right->wantedLOD != right->currentLOD ),
262                        topChanged              = ( top && top->isActive() ) && 
263                                ( top->wantedLOD != currentLOD ),
264                        bottomChanged   = ( bottom && bottom->isActive() ) && 
265                                ( bottom->wantedLOD != bottom->currentLOD ),
266                        iChanged                =  wantedLOD != currentLOD;
267                               
268        return ( leftChanged || rightChanged || topChanged || bottomChanged || 
269                forceTesselation || iChanged );
270}
271
272void TerrainPage::updateTesselation( )
273{
274        assert( wantedLOD < 5 && wantedLOD >= 0 );
275        if ( needsRetesselation() ) {
276                tesselate( wantedLOD );
277        }       
278        currentLOD = wantedLOD;
279       
280        //Check if the page is a level four page. If yes, copy the vertex and index data into
281        //the shared level four page buffers.
282        if ( currentLOD == TerrainPage::MAX_LODS-1 ) {
283                owner->addLevelFourPage( numVertices, vertices, 
284                        numIndices, indices );
285        }
286        forceTesselation = false;
287}
288
289void TerrainPage::tesselateTopRow(  int _z, int _stride, 
290        bool _adaptLeft,  bool _adaptRight )
291{
292        int halfStride = _stride/2;
293        int xStart = 0, xEnd= owner->getPageSize()-1;
294        int size = xEnd;
295        int z = xEnd-_stride ; 
296        addAgain();
297        addIndex( getIndex( 0, z ) );
298        assert(halfStride>=1);
299
300        if( _adaptLeft ) {
301                addIndex( getIndex( 0, z ) );
302                addIndex( getIndex( 0, z+halfStride ) );
303                addIndex( getIndex( _stride, z ) );
304                addIndex( getIndex( 0, size ) );
305                addIndex( getIndex( halfStride, size ) );
306                addAgain();
307                addIndex( getIndex( _stride, z ) );
308                addIndex( getIndex( _stride, size ) );
309                xStart = _stride;
310        }
311
312        if ( _adaptRight )
313                xEnd -= _stride;
314        for ( int x = xStart; x < xEnd; x+=_stride ) {
315                addIndex( getIndex( x, z ) );
316                addIndex( getIndex( x, size ) );
317                addIndex( getIndex( x+_stride, z ) );
318                addIndex( getIndex( x+halfStride, size ) );
319                addIndex( getIndex( x+_stride, size ) );
320                addAgain();
321        }
322
323        if ( _adaptRight ) {
324                addIndex( getIndex( xEnd, z ) );
325                addIndex( getIndex( xEnd, size ) );
326                addIndex( getIndex( size, z ) );
327                addIndex( getIndex( xEnd+halfStride, size ) );
328                addIndex( getIndex( size, size-halfStride ) );
329                addIndex( getIndex( size, size ) );
330        }
331
332}
333void TerrainPage::tesselateBottomRow(  int _z,  int _stride, 
334        bool _adaptLeft,  bool _adaptRight  )
335{
336        int halfStride = _stride/2;
337        int xStart=0, xEnd=owner->getPageSize()-1;
338        int size = xEnd;
339        assert( halfStride>=1 );
340
341        if ( _adaptLeft ) {
342                addIndex( getIndex( 0, 0 ) );
343                addIndex( getIndex( 0, halfStride ) );
344                addIndex( getIndex( halfStride, 0 ) );
345                addIndex( getIndex( 0, _stride ) );
346                addIndex( getIndex( _stride, 0 ) );
347                addIndex( getIndex( _stride, _stride ) );
348                xStart = _stride;
349        }
350
351
352        if ( _adaptRight )
353                xEnd -= _stride;
354
355        for ( int x = xStart; x < xEnd; x+=_stride ) {
356                addIndex( getIndex( x, 0 ) );
357                addAgain();
358                addIndex( getIndex( x+halfStride, 0 ) );
359                addIndex( getIndex( x, _stride ) );
360                addIndex( getIndex( x+_stride ,0 ) );
361                addIndex( getIndex( x+_stride, _stride ) );
362        }
363
364
365        if( _adaptRight ) {
366                addIndex( getIndex( xEnd,0 ) );
367                addIndex( getIndex( xEnd,_stride ) );
368                addIndex( getIndex( xEnd+halfStride, 0 ) );
369                addIndex( getIndex( size ,0 ) );
370                addAgain();
371                addIndex( getIndex( xEnd, _stride ) );
372                addIndex( getIndex( size, halfStride ) );
373                addIndex( getIndex( size, _stride ) );
374        }
375}
376
377void TerrainPage::tesselateLevelFourPage( bool _adapt[] )
378{
379        assert( indices ); assert( vertices );
380        numIndices = numVertices = 0;
381        const int       halfStride = 8, stride = 16;
382       
383        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, 
386                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 ) | 
391                                                ( _adapt[TP_TOP]        ? ADAPT_T : 0 );
392        switch( code ) {
393                case ADAPT_NONE:
394                        addIndex( getIndex( 0, 0 ) );
395                        addIndex( getIndex( 0, stride ) );
396                        addIndex( getIndex( stride, 0 ) );
397                        addIndex( getIndex( stride, stride ) );
398                        break;
399                       
400                case ADAPT_L:
401                        addIndex( getIndex( 0, 0 ) );
402                        addIndex( getIndex( 0, halfStride ) );
403                        addIndex( getIndex( stride, 0 ) );
404                        addIndex( getIndex( 0, stride ) );
405                        addIndex( getIndex( stride, stride ) );
406                        addAgain( );
407                        break;
408               
409                case ADAPT_R:
410                        addIndex( getIndex( stride, stride ) );
411                        addIndex( getIndex( stride, halfStride ) );
412                        addIndex( getIndex( 0, stride ) );
413                        addIndex( getIndex( stride, 0 ) );
414                        addIndex( getIndex( 0, 0 ) );
415                        addAgain( );
416                        break;
417
418                case ADAPT_LR:
419                        addIndex( getIndex( 0, 0 ) );
420                        addIndex( getIndex( 0, halfStride ) );
421                        addIndex( getIndex( stride, 0 ) );
422                        addIndex( getIndex( 0, stride ) );
423                        addIndex( getIndex( stride, halfStride ) );
424                        addIndex( getIndex( stride, stride ) );
425                        break;
426
427                case ADAPT_B:
428                        addIndex( getIndex( 0, 0 ) );
429                        addAgain();
430                        addIndex( getIndex( halfStride, 0 ) );
431                        addIndex( getIndex( 0, stride ) );
432                        addIndex( getIndex( stride, 0 ) );
433                        addIndex( getIndex( stride, stride ) );
434                        break;
435
436                case ADAPT_LB:
437                        addIndex( getIndex( 0, 0 ) );
438                        addIndex( getIndex( 0, halfStride ) );
439                        addIndex( getIndex( halfStride, 0 ) );
440                        addIndex( getIndex( 0, stride ) );
441                        addIndex( getIndex( stride, 0 ) );
442                        addIndex( getIndex( stride, stride ) );
443                        break;
444
445                case ADAPT_RB:
446                        addIndex( getIndex( 0, 0 ) );
447                        addIndex( getIndex( 0, stride ) );
448                        addIndex( getIndex( halfStride, 0 ) );
449                        addIndex( getIndex( stride, 0 ) );
450                        addAgain( );
451                        addIndex( getIndex( 0, stride ) );
452                        addIndex( getIndex( stride, halfStride ) );
453                        addIndex( getIndex( stride, stride ) );
454                        break;
455
456                case ADAPT_LRB:
457                        addIndex( getIndex( stride, stride ) );
458                        addIndex( getIndex( stride, halfStride ) );
459                        addIndex( getIndex( 0, stride ) );
460                        addIndex( getIndex( stride, 0 ) );
461                        addIndex( getIndex( 0, halfStride ) );
462                        addIndex( getIndex( halfStride, 0 ) );
463                        addIndex( getIndex( 0, 0 ) );
464                        addAgain( );
465                        break;
466
467                case ADAPT_T:
468                        addIndex( getIndex( stride, stride ) );
469                        addAgain( );
470                        addIndex( getIndex( halfStride, stride ) );
471                        addIndex( getIndex( stride, 0 ) );
472                        addIndex( getIndex( 0, stride ) );
473                        addIndex( getIndex( 0, 0 ) );
474                        break;
475
476                case ADAPT_LT:
477                        addIndex( getIndex( stride, stride ) );
478                        addIndex( getIndex( stride, 0 ) );
479                        addIndex( getIndex( halfStride, stride ) );
480                        addIndex( getIndex( 0, stride ) );
481                        addAgain( );
482                        addIndex( getIndex( stride, 0 ) );
483                        addIndex( getIndex( 0, halfStride ) );
484                        addIndex( getIndex( 0, 0 ) );
485                        break;
486
487                case ADAPT_RT:
488                        addIndex( getIndex( stride, stride ) );
489                        addIndex( getIndex( stride, halfStride ) );
490                        addIndex( getIndex( halfStride, stride ) );
491                        addIndex( getIndex( stride, 0 ) );
492                        addIndex( getIndex( 0, stride ) );
493                        addIndex( getIndex( 0, 0 ) );
494                        break;
495
496                case ADAPT_LRT:
497                        addIndex( getIndex( 0, 0 ) );
498                        addIndex( getIndex( 0, halfStride ) );
499                        addIndex( getIndex( stride, 0 ) );
500                        addIndex( getIndex( 0, stride ) );
501                        addIndex( getIndex( stride, halfStride ) );
502                        addIndex( getIndex( halfStride, stride ) );
503                        addIndex( getIndex( stride, stride ) );
504                        addAgain( );
505                        break;
506
507                case ADAPT_BT:
508                        addIndex( getIndex( 0, 0 ) );
509                        addAgain( );
510                        addIndex( getIndex( halfStride, 0 ) );
511                        addIndex( getIndex( 0, stride ) );
512                        addIndex( getIndex( stride, 0 ) );
513                        addIndex( getIndex( halfStride, stride ) );
514                        addIndex( getIndex( stride, stride ) );
515                        addAgain( );
516                        break;
517
518                case ADAPT_LBT:
519                        addIndex( getIndex( 0, 0 ) );
520                        addIndex( getIndex( 0, halfStride ) );
521                        addIndex( getIndex( halfStride, 0 ) );
522                        addIndex( getIndex( 0, stride ) );
523                        addIndex( getIndex( stride, 0 ) );
524                        addIndex( getIndex( halfStride, stride ) );
525                        addIndex( getIndex( stride, stride ) );
526                        addAgain( );
527                        break;
528
529                case ADAPT_RBT:
530                        addIndex( getIndex( stride, stride ) );
531                        addIndex( getIndex( stride, halfStride ) );
532                        addIndex( getIndex( halfStride, stride ) );
533                        addIndex( getIndex( stride, 0 ) );
534                        addIndex( getIndex( 0, stride ) );
535                        addIndex( getIndex( halfStride, 0 ) );
536                        addIndex( getIndex( 0, 0 ) );
537                        addAgain( );
538                        break;
539
540                case ADAPT_LRBT:
541                        addIndex( getIndex( 0, 0 ) );
542                        addIndex( getIndex( 0, halfStride ) );
543                        addIndex( getIndex( halfStride, 0 ) );
544                        addIndex( getIndex( 0, stride ) );
545                        addIndex( getIndex( stride, 0 ) );
546                        addIndex( getIndex( halfStride, stride ) );
547                        addIndex( getIndex( stride, halfStride ) );
548                        addIndex( getIndex( stride, stride ) );
549                        break;
550        }
551        assert( numIndices % 2 == 0 );
552}
553
554
555void TerrainPage::tesselate( int _lod )
556{
557
558        memset( indexHash, 0xffff, 
559                        sizeof(unsigned short)*Terrain::MAX_VERTICES );
560       
561        numVertices = 0; numIndices = 0;
562       
563        //Calculate the pace, based on the lod.
564        int stride = 1 << _lod;
565               
566        bool adapt[4];
567        determineBorderAdaption( adapt );
568        assert( isVisible );
569#ifdef USE_VBO
570        if ( _lod == TerrainPage::MAX_LODS-1 ) {
571                if ( vbIdentifier && ibIdentifier ) {
572                        owner->getBufferBroker()->release( vbIdentifier, ibIdentifier );
573                        vbIdentifier = ibIdentifier = 0;
574                }
575                if ( !vertices ) 
576                        vertices =  new Vertex[8]; 
577                if ( !indices )
578                        indices = new unsigned short[8];
579        }
580        else {
581                if ( !vbIdentifier && !ibIdentifier ) {
582                        owner->getBufferBroker()->acquire( vbIdentifier, ibIdentifier );
583                        if ( vertices )
584                                delete[] vertices;
585                        if ( indices )
586                                delete[] indices;
587                        vertices = NULL; indices = NULL;       
588                }
589                assert( vbIdentifier ); assert( ibIdentifier );
590                glBindBufferARB( GL_ARRAY_BUFFER_ARB, vbIdentifier );
591
592                // 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 ), 
599                        NULL, GL_DYNAMIC_DRAW_ARB );
600
601                vertices = (Vertex*)glMapBufferARB( GL_ARRAY_BUFFER_ARB, 
602                        GL_WRITE_ONLY_ARB );
603
604                glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, ibIdentifier );
605
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, 
610                        GL_WRITE_ONLY_ARB );
611
612        }       
613
614#endif 
615
616        assert( indices );      assert( vertices );
617        if ( _lod == TerrainPage::MAX_LODS-1 ) {
618                tesselateLevelFourPage( adapt );
619                return;
620        }
621       
622        int zStart = 0, zEnd = owner->getPageSize()-stride;
623       
624        if ( adapt[TP_BOTTOM] ) {
625                tesselateBottomRow( 0, stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
626                zStart+= stride;
627        }
628       
629        if ( adapt[TP_TOP] )
630                zEnd-= stride;
631               
632        for ( int z = zStart; z < zEnd; z+=stride )
633                tesselateRow( z, stride, stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
634       
635
636        if ( adapt[TP_TOP] ) {
637                tesselateTopRow( owner->getPageSize()-stride-1, 
638                        stride, adapt[TP_LEFT], adapt[TP_RIGHT] );
639        }
640       
641#ifdef USE_VBO
642        if ( vbIdentifier && ibIdentifier ) {
643                glUnmapBufferARB( GL_ARRAY_BUFFER_ARB );
644                indices = NULL;
645                glUnmapBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB );
646                vertices = NULL;
647        }       
648#endif
649
650}
651
652
653void TerrainPage::show( )
654{
655       
656#ifdef USE_VBO 
657        //This is done later on...
658        //owner->getBufferBroker()->acquire( vbIdentifier, ibIdentifier );
659        vertices = NULL;
660        indices = NULL;
661#else
662        vertices = new Vertex[Terrain::MAX_VERTICES];
663        indices = new unsigned short[Terrain::MAX_INDICES];
664#endif 
665        vbIdentifier = 0; ibIdentifier = 0;
666        indexHash = new unsigned short[Terrain::MAX_VERTICES]; 
667        forceTesselation = true;
668        activate();
669        active = true;
670}
671
672void TerrainPage::hide( )
673{
674#ifdef USE_VBO
675        owner->getBufferBroker()->release( vbIdentifier, ibIdentifier );       
676#endif
677        SAVE_DELETE_ARRAY( vertices );
678        numVertices = 0;
679        SAVE_DELETE_ARRAY( indices );
680        numIndices = 0;
681        deactivate();
682}
683
684void TerrainPage::drawBox()
685{
686        glMatrixMode( GL_MODELVIEW );
687        glPushMatrix();
688        glTranslatef( bounds.corner.x, bounds.corner.y, bounds.corner.z );
689        glBegin( GL_QUADS );
690                glVertex3f( 0.0f, 0.0f, 0.0f );
691                glVertex3f(  bounds.x, 0.0f, 0.0f );
692                glVertex3f( bounds.x, bounds.y, 0.0f );
693                glVertex3f( 0.0f, bounds.y, 0.0f );
694               
695                glVertex3f( 0.0f, 0.0f, bounds.z );
696                glVertex3f(  bounds.x, 0.0f, bounds.z );
697                glVertex3f( bounds.x, bounds.y, bounds.z );
698                glVertex3f( 0.0f, bounds.y, bounds.z );         
699               
700                glVertex3f( 0.0f, 0.0f, 0.0 );
701                glVertex3f(  0.0, 0.0f, bounds.z );
702                glVertex3f( 0.0f, bounds.y, bounds.z );
703                glVertex3f( 0.0f, bounds.y, 0.0f );                             
704               
705                glVertex3f( bounds.x, 0.0f, 0.0 );
706                glVertex3f(  bounds.x, 0.0f, bounds.z );
707                glVertex3f( bounds.x, bounds.y, bounds.z );
708                glVertex3f( bounds.x, bounds.y, 0.0f );                                         
709        glEnd();
710        glPopMatrix();
711}
712//TODO: put all the pages that have a coarses tesselation level than 4 into a
713//              separate list!
714void TerrainPage::draw( )
715{
716        assert( glIsEnabled( GL_VERTEX_ARRAY ) );
717        assert( !glIsEnabled( GL_NORMAL_ARRAY ) );
718       
719        if ( currentLOD == TerrainPage::MAX_LODS-1 )
720                return;
721               
722        assert( isVisible ); assert( numIndices > 0 );
723        active = false;
724        CHECK_GL_ERROR( "1" ); 
725#ifdef USE_VBO
726       
727        glBindBufferARB( GL_ARRAY_BUFFER_ARB, vbIdentifier );
728        glClientActiveTextureARB( GL_TEXTURE0_ARB );
729        glInterleavedArrays( GL_T2F_V3F, 0, NULL );
730       
731        glClientActiveTextureARB( GL_TEXTURE1_ARB );
732        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   
739        glClientActiveTextureARB( GL_TEXTURE0_ARB );
740        glInterleavedArrays( GL_T2F_V3F, 0, vertices );
741       
742        glClientActiveTextureARB( GL_TEXTURE1_ARB );
743        glInterleavedArrays( GL_T2F_V3F, 0, vertices );
744       
745        glDrawElements( GL_TRIANGLE_STRIP, numIndices, 
746                                        GL_UNSIGNED_SHORT, indices );   
747#endif
748       
749
750       
751        if ( owner->debug() )
752                drawBox( );
753               
754        CHECK_GL_ERROR( "2" ); 
755}
756
757unsigned short TerrainPage::getIndex( int _x, int _z )
758{
759        unsigned short index = _z*owner->getPageSize()+_x;
760        if ( indexHash[index] == 0xffff ) {
761                //The vertex didn't exists before, lets create it.
762                indexHash[index] = numVertices;
763                getVertex( _x, _z, vertices[numVertices].p );
764                getCoord( _x, _z, vertices[numVertices].t );
765                numVertices++;
766        }
767        return indexHash[index];
768}
769
770void TerrainPage::getCoord( int _x, int _z, TexCoord& _coord ) const 
771{
772        owner->getCoord( _x+xOffset*(owner->getPageSize()-1 ), 
773                                         _z+zOffset*(owner->getPageSize()-1 ), _coord );
774}
775
776void TerrainPage::getVertex( int _x, int _z, Vector& _vertex ) const
777{
778        _vertex.x = position.x+scale.x*_x/
779                ( owner->getPageSize()-1 );
780        _vertex.y = getAltitude( _x, _z );
781        _vertex.z = position.z+scale.z*_z/( owner->getPageSize()-1 );
782}
783void TerrainPage::setLayerVisibility( int _layer, LayerVisibility _lv )
784{
785        if ( hasfull ) return;
786        if ( _lv == LV_FULL ) {
787                for ( int i = 0; i < 8; ++i )
788                        layerVisibility[i] = LV_NO;
789                if ( _layer )
790                        hasfull = true;
791        }       
792        layerVisibility[_layer] = _lv; 
793}
794
795bool TerrainPage::hasMaterial( int _layer )
796{ 
797        return ( layerVisibility[_layer] != LV_NO );
798}
799void TerrainPage::calculateErrors()
800{
801        for ( int i = 0; i < TerrainPage::MAX_LODS; ++i )
802                calculateError( i );
803}
Note: See TracBrowser for help on using the repository browser.