D:/simple_rts/src/FogOfWar.cpp

Go to the documentation of this file.

#include "FogOfWar.h"

#include "Level.h"
#include "Unit.h"

#include <memory>

#include "OgreHardwareBuffer.h"
#include "OgreString.h"
#include "OgreStringConverter.h"
#include "OgreTextureManager.h"
#include "OgreVector3.h"

#include "OgreMaterialManager.h"
#include "OgreMaterial.h"
#include "OgreTechnique.h"
#include "OgrePass.h"
#include "OgreTextureUnitState.h"
using namespace Ogre;

using Ogre::HardwareBuffer;
using Ogre::String;
using Ogre::StringConverter;
using Ogre::TextureManager;


namespace ASR
{
        int FogOfWar::mNumFogs = 0;

        // ----------------------------------------------------------------------------
        FogOfWar::FogOfWar ( int width, int height )
                : mWidth ( width ), mHeight ( height )
        {
                mBuffer = new unsigned int[ width * height ];
                memset ( mBuffer, 0x00000000, width * height * sizeof(unsigned int) );


                String name = "fogOfWar_" + StringConverter::toString ( mNumFogs );
                mFogTexture = TextureManager::getSingleton().createManual ( name, "General", Ogre::TEX_TYPE_2D, width, height, 1, Ogre::PF_A8R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY );
                mPixBuffer = mFogTexture->getBuffer ();

                // HACK
                //              This should create a copy of the terrain material and only modify that
                //              locally (for network support)
                if ( mNumFogs == 0 )
                {
                        MaterialPtr mat = MaterialManager::getSingleton ().getByName ( "ASR/Terrain" );
                        Technique* tech = mat->getSupportedTechnique ( 0 );
                        Pass* pass = tech->getPass ( 0 );
                        TextureUnitState* state = pass->createTextureUnitState ( name, 0 );
                        state->setColourOperationEx ( Ogre::LBX_MODULATE );
                }


                mNumFogs++;
        }


        // ----------------------------------------------------------------------------
        FogOfWar::~FogOfWar ()
        {
                mFogTexture.setNull ();
                mPixBuffer.setNull ();

                delete[] mBuffer;
        }


        // ----------------------------------------------------------------------------
        void FogOfWar::blackOut ()
        {
                memset ( mBuffer, 0, mWidth * mHeight * sizeof(unsigned int) );
        }


        // ----------------------------------------------------------------------------
        void FogOfWar::fadeOut ()
        {
                for ( int y = 0; y < mHeight; y++ )
                {
                        for ( int x = 0; x < mWidth; x++ )
                        {
                                if ( mBuffer[y * mWidth + x] > 0x88888888 )
                                {
                                        mBuffer[y * mWidth + x] -= 0x05050505;
                                }
                        }
                }
        }


        // ----------------------------------------------------------------------------
        void FogOfWar::updateTexture ()
        {
                mPixBuffer->lock ( HardwareBuffer::HBL_DISCARD );

                const PixelBox& pb = mPixBuffer->getCurrentLock ();
                for ( unsigned int y = 0; y < pb.getHeight (); y++ )
                {
                        unsigned int *data = static_cast<unsigned int*>(pb.data) + y*pb.rowPitch;
                        unsigned int *src = mBuffer + (y * mWidth);
                        memcpy ( data, src, pb.getWidth() * sizeof(unsigned int) );
                }

                mPixBuffer->unlock ();
        }


        // ----------------------------------------------------------------------------
        void FogOfWar::setVisible ( int x, int y, int radius )
        {
                // Draw a filled circle using Bresenham's Circle Algorithm

                x = (float)x / ( Level::getSingleton ().getWorldWidth () / Level::getSingleton ().getNumNodesWide () );
                y = (float)y / ( Level::getSingleton ().getWorldHeight () / Level::getSingleton ().getNumNodesHigh () );

                // TODO
                //              How do we scale a radius in a non-rectangular grid (use ellipses)
                radius = (float)radius / (Level::getSingleton ().getWorldHeight () / Level::getSingleton ().getNumNodesHigh ());

                int p = 1 - radius;

                // Start at the top position
                int x0 = 0;
                int y0 = radius;


                _drawHorizontalLine ( x - radius, x + radius, y );

                while ( x0 < y0 )
                {
                        x0++;

                        _drawHorizontalLine ( x - y0, x + y0, y + x0 );
                        _drawHorizontalLine ( x - y0, x + y0, y - x0 );

                        if ( p < 0 )
                        {
                                p += 2 * x0 + 1;
                        }
                        else
                        {
                                _drawHorizontalLine ( x - x0, x + x0, y + y0 );
                                _drawHorizontalLine ( x - x0, x + x0, y - y0 );

                                y0--;
                                p += 2 * ( x0 - y0 ) + 1;
                        }
                }
        }


        // ----------------------------------------------------------------------------
        void FogOfWar::_drawHorizontalLine ( int xStart, int xEnd, int y )
        {
                if ( xStart > xEnd )
                {
                        int temp = xStart;
                        xStart = xEnd;
                        xEnd = temp;
                }

                // Clamping
                if ( y < 0 )
                        return;
                if ( y >= mHeight )
                        return;
                if ( xStart >= mWidth )
                        return;
                if ( xEnd < 0 )
                        return;

                if ( xStart < 0 )
                        xStart = 0;
                if ( xEnd >= mWidth )
                        xEnd = mWidth - 1;
                // End Clamping

                memset ( mBuffer + (y*mWidth) + xStart, 0xFFFFFFFF, (xEnd - xStart + 1) * sizeof(unsigned int) );
        }


        // ----------------------------------------------------------------------------
        bool FogOfWar::isUnitVisible ( const Unit* unit ) const
        {
                // TODO
                //              Implement a more robust check consisting of the entire
                //              bounding region of the unit, not just its center point

                Vector3 pos = unit->getPosition ();
                pos.x /= ( Level::getSingleton ().getWorldWidth () / Level::getSingleton ().getNumNodesWide () );
                pos.z /= ( Level::getSingleton ().getWorldHeight () / Level::getSingleton ().getNumNodesHigh () );

                return ( mBuffer[ int(pos.z) * mWidth + int(pos.x) ] == 0xFFFFFFFF );
        }
}

---