D:/simple_rts/src/TeamUpdater.cpp

Go to the documentation of this file.

#include "TeamUpdater.h"

#include "Team.h"
#include "TeamUnits.h"
#include "TeamBuildings.h"

#include "FogOfWar.h"
#include "Unit.h"
#include "TeamUnits.h"

#include "OgreMaterialManager.h"
#include "OgreMaterial.h"
#include "OgreEntity.h"
#include "OgreSubEntity.h"
using namespace Ogre;

#include "OgreVector3.h"
using Ogre::Vector3;


namespace ASR
{
        // ----------------------------------------------------------------------------
        TeamUpdater::TeamUpdater ( Team* team )
                : mTeam ( team )
        {
                mFadeTime = 0.0f;
        }


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


        // ----------------------------------------------------------------------------
        bool TeamUpdater::updateBeforeFrame ( const Ogre::FrameEvent& e, const Ogre::InputReader* inputDevice )
        {
                mTeam->mUnits->animateUnits( e.timeSinceLastFrame );
                mTeam->mUnits->moveUnits ( e.timeSinceLastFrame );

                mTeam->mUnits->updateSpatialGrid ();

                // TODO
                //              Make some constants for the timeToFadeOneUnit
                // Update the fog of war
                mFadeTime += e.timeSinceLastFrame;
                if ( mFadeTime >= 0.05f )
                {
                        mTeam->mFogOfWar->fadeOut ();
                        mFadeTime -= 0.05f;
                }

                TeamUnits::UnitIterator iter = mTeam->getUnitIterator ();
                while ( iter.hasMoreElements () )
                {
                        Unit* unit = iter.getNext ();
                        if ( !unit->isDead () )
                                mTeam->mFogOfWar->setVisible ( unit->getPosition().x, unit->getPosition().z, unit->getSightRadius () );
                }
                mTeam->mFogOfWar->updateTexture ();

                return true;
        }


        // ----------------------------------------------------------------------------
        bool TeamUpdater::updateAfterFrame ( const Ogre::FrameEvent& e, const Ogre::InputReader* inputDevice )
        {
                // Only find the targets after the frame has passed so that each unit
                // from each team is now in their final positions
                mTeam->mUnits->findTargets ();
                mTeam->mUnits->performAttacks ();

                // HACK
                //              Fade units out
                static float alpha = 1.0f;
                alpha -= ( 1.0f / 5.0f ) * e.timeSinceLastFrame;
                if ( alpha < 0.0f )
                        alpha = 1.0f;

                Unit* unit = mTeam->mUnits->getUnit ( 0 );
                MaterialPtr mat = unit->getEntity ()->getSubEntity (0)->getMaterial ();
                //mat->getSupportedTechnique (0)->getPass(0)->setSceneBlending ( Ogre::SBT_ADD );
                //mat->getSupportedTechnique (0)->getPass(0)->setDiffuse ( alpha, alpha, alpha, alpha );
                //mat->getSupportedTechnique (0)->getPass(0)->setAmbient ( alpha, alpha, alpha );


                
                /*
                unsigned short i = 0, j;
                ColourValue sc, dc; // Source colur, destination colour
                Material::TechniqueIterator techniqueIt = mat->getTechniqueIterator ();
                while (techniqueIt.hasMoreElements ())
                {
                        Technique *t = techniqueIt.getNext ();
                        Technique::PassIterator passIt = t->getPassIterator ();
                        j = 0;
                        while (passIt.hasMoreElements ())
                        {
                                sc = mat->getTechnique (i)->getPass (j)->getDiffuse ();

                                Ogre::SceneBlendType mSBT = SBT_TRANSPARENT_ALPHA;

                                switch (mSBT)
                                {
                                case SBT_ADD:
                                        dc = sc;
                                        dc.r -= sc.r * alpha;
                                        dc.g -= sc.g * alpha;
                                        dc.b -= sc.b * alpha;
                                        passIt.peekNext ()->setAmbient (ColourValue::Black);
                                        break;
                                case SBT_TRANSPARENT_ALPHA:
                                default:
                                        dc = sc;
                                        dc.a = sc.a * (1.0f - alpha);
                                        passIt.peekNext ()->setAmbient (mat->getTechnique (i)->getPass (j)->getAmbient ());
                                        break;
                                }
                                passIt.peekNext ()->setDiffuse (dc);
                                passIt.moveNext ();

                                ++j;
                        }

                        ++i;
                }
                */
                

                return true;
        }
}

---