D:/simple_rts/src/LevelStatusVisualizer.cpp

Go to the documentation of this file.

#include "LevelStatusVisualizer.h"

#include "Unit.h"

#include "OgreMath.h"
#include "OgrePlane.h"
#include "OgreException.h"
#include "OgreStringConverter.h"
#include "OgreVector3.h"
#include "OgreMeshManager.h"
#include "OgreResourceGroupManager.h"
#include "OgreHardwarePixelBuffer.h"
#include "OgreMaterial.h"
#include "OgreMaterialManager.h"
#include "OgrePixelFormat.h"
#include "OgreTextureManager.h"

using Ogre::Pass;
using Ogre::TextureManager;
using Ogre::HardwareBuffer;
using Ogre::Math;
using Ogre::Plane;
using Ogre::Vector3;
using Ogre::MeshManager;
using Ogre::MaterialPtr;
using Ogre::MaterialManager;
using Ogre::ResourceGroupManager;
using Ogre::HardwarePixelBufferSharedPtr;
using Ogre::PixelBox;
using Ogre::StringConverter;
using Ogre::TextureUnitState;



namespace ASR
{
        // ----------------------------------------------------------------------------
        LevelStatusVisualizer::LevelStatusVisualizer( Level* lev )
                : mLevel ( lev )
        {
                // Create a dynamic texture
                tex = TextureManager::getSingleton ().createManual (
                        "DynamicTexture", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
                        Ogre::TEX_TYPE_2D, mLevel->mCellsWide, mLevel->mCellsHigh, 0, Ogre::PF_BYTE_BGRA, Ogre::TU_DYNAMIC_WRITE_ONLY );

                
                // Add another layer onto the terrain to show the occlusion information
                MaterialPtr material = MaterialManager::getSingleton ().getByName ( "ASR/Terrain" );
                TextureUnitState* texState = material->getTechnique (0)->getPass (0)->createTextureUnitState ( "DynamicTexture" );
                texState->setColourOperation ( Ogre::LBO_ADD );

                texState->setTextureFiltering ( Ogre::FO_POINT, Ogre::FO_POINT, Ogre::FO_NONE );

                _rebuild();
        }


        // ----------------------------------------------------------------------------
        LevelStatusVisualizer::~LevelStatusVisualizer(void)
        {
        }


        // ----------------------------------------------------------------------------
        bool LevelStatusVisualizer::updateBeforeFrame ( const FrameEvent& e, const InputReader* inputDevice )
        {
                _rebuild ();

                return true;
        }


        // ----------------------------------------------------------------------------
        bool LevelStatusVisualizer::updateAfterFrame ( const FrameEvent& e, const InputReader* inputDevice )
        {
                return true;
        }


        // ----------------------------------------------------------------------------
        void LevelStatusVisualizer::_rebuild ()
        {
                HardwarePixelBufferSharedPtr pixBuf = tex->getBuffer ();
                pixBuf->lock ( HardwareBuffer::HBL_DISCARD );
                const PixelBox& pixelBox = pixBuf->getCurrentLock ();

                unsigned char* pBuf = static_cast<unsigned char*>(pixelBox.data);
                unsigned char* data = pBuf;

                _paintBlockedTiles ( data, pixelBox.getRowSkip () );
                _paintUnitPaths ( data, pixelBox.getRowSkip () );

                pixBuf->unlock ();
        }


        // ----------------------------------------------------------------------------
        void LevelStatusVisualizer::_paintUnitPaths ( unsigned char* data, unsigned int rowSkip )
        {
                Level::TeamIterator teamIter = mLevel->getTeamIterator ();

                // For each team
                while ( teamIter.hasMoreElements () )
                {
                        Team* curTeam = teamIter.getNext ();

                        // For each unit on the team
                        TeamUnits::UnitIterator unitIter = curTeam->getUnitIterator ();
                        while ( unitIter.hasMoreElements () )
                        {
                                Unit* curUnit = unitIter.getNext ();
                                if ( curUnit->hasDestination () )
                                {
                                        // For each waypoint of each unit on each team
                                        Unit::WaypointIterator wayIter = curUnit->getWaypointIterator ();
                                        while ( wayIter.hasMoreElements () )
                                        {
                                                Vector3 dest = wayIter.getNext ();
                                                int x;
                                                int z;

                                                mLevel->getCellLocation ( dest, &x, &z );
                                                
                                                int index;
                                                index = z * ( mLevel->mCellsWide * 4 );
                                                index += z * rowSkip * 4;
                                                index += x * 4;

                                                data[ index + 0] = 255;
                                                data[ index + 1] = 255;
                                                data[ index + 2] = 255;
                                                data[ index + 3] = 155;
                                        }
                                }
                        }
                }
        }


        // ----------------------------------------------------------------------------
        void LevelStatusVisualizer::_paintBlockedTiles ( unsigned char* data, unsigned int rowSkip )
        {
                for ( unsigned int j = 0; j < mLevel->mCellsHigh; j++ )
                {
                        for ( unsigned int i = 0; i < mLevel->mCellsWide; i++ )
                        {
                                if ( mLevel->mOccupied[ (j * mLevel->mCellsWide) + i ].getTraversalCost () < 0.0f )
                                {
                                        data[i*4] = 0;
                                        data[i*4 + 1] = 0;
                                        data[i*4 + 2] = 125;
                                        data[i*4 + 3] = 80;
                                }
                                else
                                {
                                        data[i*4] = 0;
                                        data[i*4 + 1] = 0;
                                        data[i*4 + 2] = 0;
                                        data[i*4 + 3] = 80;
                                }
                        }
                        data += (mLevel->mCellsWide * 4) + (rowSkip * 4);
                }
        }
}

---