source: orxonox.OLD/branches/terrain/src/lib/graphics/importer/terrain/terrain.h @ 8741

/*
        orxonox - the future of 3D-vertical-scrollers
 
        Copyright (C) 2006 orx
 
        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2, or (at your option)
        any later version.
 
        ### File Specific:
        main programmer: Marco Biasini

 */

#ifndef _TERRAIN_H
#define _TERRAIN_H

#define USE_VBO
#ifdef USE_VBO
#include "buffer_broker.h"
#endif
#include "types.h"
#include "terrain_page.h"
#include "terrain_quad.h"
#include <cstdlib>
#include <string>
#include <list>
#include "material.h"
#include "texture.h"
#include "frustum.h"


typedef struct {
        int                     width;
        int                     height;
        int                             pitch;
        UByte                   *data;
} Heightfield, *pHeightfield;

struct BufferInfo {
        
        unsigned int    vbIdentifier,
                                        ibIdentifier,
                                        numIndices,
                                        numVertices;
        
        BufferInfo( unsigned int _vb, unsigned int _ib, 
                unsigned int _numV, unsigned int _numI )
        {
                vbIdentifier = _vb; ibIdentifier = _ib; 
                numIndices = _numI; numVertices =_numV;
                
        }
        
        BufferInfo()
        {
                vbIdentifier = ibIdentifier = numIndices = numVertices = 0;
        }
};


class Terrain;

typedef Terrain *pTerrain;

class TerrainPage;

class Terrain {
        public:
                const static int PAGE_SIZE                      = 17;
                const static int MAX_VERTICES           = PAGE_SIZE*PAGE_SIZE;
                const static int MAX_INDICES            = 2*( PAGE_SIZE*PAGE_SIZE + PAGE_SIZE -2 );
                /**
                 * The amount of geometry rendered is largely depending on this constant. So chose a
                 * reasonable value...
                 */
                inline float getDetail() { return 0.02f; }

        
                inline bool debug()
                {
                        return false;
                }
                
                inline pTerrainPage getActiveList() { return activePages; }

        
                inline void setCameraPosition( const Triple& _cameraPosition ) 
                { 
                        cameraPosition = _cameraPosition; 
                }
                
                inline const Triple& getCameraPosition() const
                {
                        return cameraPosition;
                }
        
                void getAltitude( Triple& _alt, Triple& _normal );
                
                //What a bad name: Need to rename that :(
                void addLevelFourPage( int _numVertices, Vertex *_vertices, 
                        int _numIndices, unsigned short *_indices );
                void showPages( int _x0, int _z0, int _width, int _height );
                                        
                /**
                 * Create a new terrain.
                 */
                Terrain( )
                { 
                        pageSize = 17;
                        scale  = Triple( 1.0f, 3.0f, 1.0f );
                        frustum = new Frustum();
                        activatedCount = deactivatedCount = 0;
                        vertices = new Vertex[MAX_VERTICES];
                        indices = new unsigned short[MAX_INDICES];
#ifdef USE_VBO
                        broker = new BufferBroker( 200, MAX_VERTICES*sizeof( Vertex ), 
                                MAX_INDICES*sizeof( short ) );
#endif                  
                }
                
                /**
                 * Draws the terrain.
                 */
                void draw( );

                void setPageSize( const Triple& _page ) { }
                
                void build();
                
                inline void setActiveList( pTerrainPage _page )
                {
                        activePages = _page;
                }
                inline pFrustum getViewingFrustum()
                {
                        return frustum;
                }
                
                /**
                 * Returns the normalized ( range from [0..1] ) altitude from the heightmap for the given 
                 * coordinates.
                 */
                inline void incActivated() { activatedCount++; }
                inline void incDeactivated() { deactivatedCount++; }
                inline float getAltitude( int _x, int _z ) const;
                
                inline void addMaterial( Material *_material )
                {
                        materials.push_back( _material );
                }
                
                /*inline void setLightmap( const std::string &_lightmap )
                {
                        lightmapSource = _lightmap;
                }*/
                inline void setHeightmap( const std::string &_heightmap ) 
                { 
                        heightmapSource = _heightmap; 
                }
                
                inline void setPageSize( int _pageSize )
                {
                        pageSize = _pageSize;
                }
                
                inline const Triple getScale() const { return scale; }
                
                inline int getPageSize() const 
                {
                        return pageSize;
                }
                
                inline void getCoord( int _x, int _z, TexCoord& _coord) const
                {
                        _coord.u = ( ( float )_x )/( heightfield.width-1 );
                        _coord.v = ( ( float )_z )/( heightfield.height-1 );                    
                }
                
                inline void setScale( const Triple& _scale )
                {
                        scale = _scale;
                }
#ifdef USE_VBO
                inline pBufferBroker getBufferBroker() { return broker; }
#endif          
                inline TerrainPage *getPage( int _x, int _z )
                {
                        return pages[pagesX*_z+_x];
                }
        protected:
                        
                /**
                 * convenience method to create a new terrain page at position offset
                 * p = ( _xOffset, _zOffset ). 
                 */
                pTerrainPage createPage( int _xOffset, int _zOffset ) const;                            
                
                /**
                 * Creates the quad tree structure for fast culling of the terrain pages.
                 */             
                pTerrainQuad createQuadTree( int _x0, int _z0, int _x1, int _z1, int _depth = 0 );
                
                /**
                 * Walks the quad tree to determine which pages are visible, e.g. are in the viewing
                 * frustum of the camera.
                 */
                void determineVisiblePages( pTerrainQuad _node );                                               
                
#ifdef USE_VBO
                pBufferBroker                           broker;
#endif
                pTerrainQuad                            root;           // The quad-tree root node.
                pTerrainPage                            *pages;         // the references to all pages
                std::string                                     heightmapSource;
                std::string                                     lightmapSource;
                Heightfield                                     heightfield;
                Triple                                          scale;
                int                                             pagesX, 
                                                                        pagesZ;
                int                                                     pageSize;       
                int                                                     cullCount;
                
                int                                                     activatedCount, 
                                                                        deactivatedCount; // For debugging and statistics
                                                                
                //The next five members are for the level 4 pages.                                              
                Vertex                                          *vertices;                                              
                unsigned short                          *indices;
                int                                                     current;
                                                                        
                std::vector<BufferInfo>         buffers;                        
                        
                Triple                                          cameraPosition;
                pFrustum                                        frustum;
                pTerrainPage                            activePages;
                std::vector<Material*>          materials;
};

inline float Terrain::getAltitude( int _x, int _z ) const
{
        return heightfield.data[heightfield.pitch*_z+_x]/255.0f;        
}

#endif