OgreTerrainZoneRenderable.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2011 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
OgreTerrainZoneRenderable.h  -  based on OgreTerrainRenderable.h from Ogre3d

-----------------------------------------------------------------------------
begin                : Thu May 3 2007
author               : Eric Cha
email                : ericcATxenopiDOTcom
-----------------------------------------------------------------------------
*/

#ifndef TERRAINZONERENDERABLE_H
#define TERRAINZONERENDERABLE_H

#include "OgreTerrainZonePrerequisites.h"
#include <OgreRenderable.h>
#include <OgreMovableObject.h>
#include <OgreAxisAlignedBox.h>
#include <OgreString.h>
#include <OgreHardwareBufferManager.h>

#include <vector>

#define MORPH_CUSTOM_PARAM_ID 77

namespace Ogre
{

    typedef map<unsigned int, IndexData* >::type IndexMap;
    typedef vector< IndexData* >::type IndexArray;
    typedef vector< IndexMap* >::type LevelArray;

    class TerrainZoneBufferCache
    {
    public:
        void shutdown(void)
        {
            for( size_t i=0; i<mCache.size(); i++ )
            {
                OGRE_DELETE mCache[i];
            }
            mCache.clear();
        }
        ~TerrainZoneBufferCache()
        {
            shutdown();
        }

        IndexArray mCache;
    };

    class TerrainZoneOptions
    {
    public:
        TerrainZoneOptions()
        {
            pageSize = 0;
            tileSize = 0;
            tilesPerPage = 0;
            maxGeoMipMapLevel = 0;
            scale = Vector3::UNIT_SCALE;
            maxPixelError = 4;
            detailTile = 1;
            lit = false;
            coloured = false;
            lodMorph = false;
            lodMorphStart = 0.5;
            useTriStrips = false;
            primaryCamera = 0;
            terrainMaterial.setNull();
        };
        size_t pageSize;
        size_t tileSize; 
        size_t tilesPerPage;
        const Camera* primaryCamera;
        size_t maxGeoMipMapLevel;
        Vector3 scale;
        size_t maxPixelError;
        bool useTriStrips;
        size_t detailTile;
        bool lodMorph;
        Real lodMorphStart;
        bool lit;
        bool coloured;
        MaterialPtr terrainMaterial;

    };

#define STITCH_NORTH_SHIFT 0
#define STITCH_SOUTH_SHIFT 8
#define STITCH_WEST_SHIFT  16
#define STITCH_EAST_SHIFT  24

#define STITCH_NORTH  128 << STITCH_NORTH_SHIFT
#define STITCH_SOUTH  128 << STITCH_SOUTH_SHIFT
#define STITCH_WEST   128 << STITCH_WEST_SHIFT
#define STITCH_EAST   128 << STITCH_EAST_SHIFT

    class _OgreOctreeZonePluginExport TerrainZoneRenderable : public Renderable, public MovableObject
    {
    public:

        TerrainZoneRenderable(const String& name, TerrainZone* tz);
        ~TerrainZoneRenderable();

        void deleteGeometry();

        enum Neighbor
        {
            NORTH = 0,
            SOUTH = 1,
            EAST = 2,
            WEST = 3,
            HERE = 4
        };

        void initialise(int startx, int startz, Real* pageHeightData);

        //movable object methods

        virtual const String& getMovableType( void ) const
        {
            return mType;
        };

        const AxisAlignedBox& getBoundingBox( void ) const
        {
            return mBounds;
        };

        virtual void _notifyCurrentCamera( Camera* cam );

        virtual void _updateRenderQueue( RenderQueue* queue );

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);
        virtual void getRenderOperation( RenderOperation& rend );

        virtual const MaterialPtr& getMaterial( void ) const
        {
            return mMaterial;
        };

        virtual void getWorldTransforms( Matrix4* xform ) const;

        virtual const Quaternion& getWorldOrientation(void) const;
        virtual const Vector3& getWorldPosition(void) const;

        inline int getRenderLevel() const
        {
            return mRenderLevel;
        };

        inline void setForcedRenderLevel( int i )
        {
            mForcedRenderLevel = i;
        }

        void _getNormalAt( float x, float y, Vector3 * result );

        float getHeightAt( float x, float y );

        bool intersectSegment( const Vector3 & start, const Vector3 & end, Vector3 * result );

        void _setNeighbor( Neighbor n, TerrainZoneRenderable *t )
        {
            mNeighbors[ n ] = t;
        };

        TerrainZoneRenderable * _getNeighbor( Neighbor n )
        {
            return mNeighbors[ n ];
        }


        void setMaterial(const MaterialPtr& m )
        {
            mMaterial = m;
        };

        void _calculateNormals();




        void _generateVertexLighting( const Vector3 &sunlight, ColourValue ambient );


        Real getSquaredViewDepth(const Camera* cam) const;

        Real getBoundingRadius(void) const { return mBoundingRadius; }

        const LightList& getLights(void) const;

        void _updateCustomGpuParameter(
            const GpuProgramParameters::AutoConstantEntry& constantEntry,
            GpuProgramParameters* params) const;
        uint32 getTypeFlags(void) const;
    protected:
        TerrainZone* mTerrainZone;
        const TerrainZoneOptions* mOptions;

        inline size_t _index( int x, int z ) const
        {
            return ( x + z * mOptions->tileSize );
        };

        inline float _vertex( int x, int z, int n )
        {
            return mPositionBuffer[x * 3 + z * mOptions->tileSize * 3 + n];
        };


        inline int _numNeighbors() const
        {
            int n = 0;

            for ( int i = 0; i < 4; i++ )
            {
                if ( mNeighbors[ i ] != 0 )
                    n++;
            }

            return n;
        }

        inline bool _hasNeighborRenderLevel( int i ) const
        {
            for ( int j = 0; j < 4; j++ )
            {
                if ( mNeighbors[ j ] != 0 && mNeighbors[ j ] ->mRenderLevel == i )
                    return true;
            }

            return false;

        }

        void _adjustRenderLevel( int i );

        bool _checkSize( int n );

        void _calculateMinLevelDist2( Real C );

        Real _calculateCFactor();

        VertexData* mTerrain;

        int mRenderLevel;
        int mLastNextLevel; 
        Real mLODMorphFactor;
        Real *mMinLevelDistSqr;
        TerrainZoneRenderable *mNeighbors [ 4 ];
        mutable bool mLightListDirty;
        mutable LightList mLightList;
        Real mBoundingRadius;
        AxisAlignedBox mBounds;
        Vector3 mCenter;
        static String mType;
        MaterialPtr mMaterial;    
        bool mInit;
        HardwareVertexBufferSharedPtr mMainBuffer;
        typedef vector<HardwareVertexBufferSharedPtr>::type VertexBufferList;
        VertexBufferList mDeltaBuffers;
        float* mPositionBuffer;
        int mForcedRenderLevel;
        int mNextLevelDown[10];
        IndexData* getIndexData(void);
        IndexData* generateTriStripIndexes(unsigned int stitchFlags);
        IndexData* generateTriListIndexes(unsigned int stitchFlags);
        int stitchEdge(Neighbor neighbor, int hiLOD, int loLOD, 
            bool omitFirstTri, bool omitLastTri, unsigned short** ppIdx);

        HardwareVertexBufferSharedPtr createDeltaBuffer(void);

    };

}

#endif