uiMgr.cpp

Go to the documentation of this file.

/*
 * uiMgr.cpp
 *
 *  Created on: Feb 18, 2012
 *      Author: sushil
 */

//using namespace OgreGFX;

#include<cfloat>

#include "DEBUG.h"
#include <engine.h>
#include <uiMgr.h>
#include <GraphicsInteractionManager.h>

#include <DebugDrawer.h>

#include <groupAI.h>
#include <unitAI.h>
#include <flock.h>
#include <target.h>
#include <command.h>

#include <commandHelp.h>
#include <const.h>
#include <enums.h>

#include <ent.h>

#include <creationMouseHandler.h>
#include <controlGroupsHandler.h>
#include "Rect.h"
#include "HealthBar.h"

OgreGFX::UIMgr::UIMgr(OgreGFX::GraphicsInteractionManager *gim) : GFXMgr(gim), OIS::KeyListener(), OIS::MouseListener(), bars(HealthBar(gim->mSceneMgr->createManualObject("manual"), 100.0f, true))
{//Engine* eng,  Ogre::RenderWindow *win, Ogre::SceneManager *sm, Ogre::Camera* cam): OgreGFX::Mgr(eng), trayMgr(0), inputManager(0), mouse(0), keyboard(0) {
    shutDown = false;
    selectionDistanceSquaredThreshold = 10000;
    camera = gfx->mCamera;
    renderWindow = gfx->mWindow;
    sceneManager = gfx->mSceneMgr;
    createInputSystem();
    //then
    cameraMgr = new OgreGFX::CameraMgr(gfx); //, camera);

    selectionBox = new OgreGFX::SelectionBox("SelectionBox");
    sceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(selectionBox);
    volQuery = sceneManager->createPlaneBoundedVolumeQuery(Ogre::PlaneBoundedVolumeList());
    rayDistanceForVolume = 10;
    selectingNow = false;
    volumeSelectingNow = false;

    clearModifiersDown();
    //currentSelection = gim->gfxNodes[0].node;

    new DebugDrawer(gfx->mSceneMgr, 0.5f);
    this->posUnderMouse = Ogre::Vector3::NEGATIVE_UNIT_Y;
    sceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(bars.emptyBar->mObj);

}

void OgreGFX::UIMgr::initialize()
{
    DEBUG(std::cout << "Calling uiMgr initializer" << std::endl;)


    std::set<OIS::KeyCode> *creationMods = new std::set<OIS::KeyCode > ();
    creationMods->insert(OIS::KC_LCONTROL);
    CreationMouseHandler *cmh = new CreationMouseHandler(this->gfx, creationMods);
    this->registerMouseHandler(creationMods, OIS::MB_Left, cmh);
    DEBUG(std::cout << "Registered creation mouse handler" << std::endl;)

    controlGroupsHandler = new ControlGroupsHandler(gfx);

    minimap = new Minimap(gfx);
    //minimap->init();

}

void OgreGFX::UIMgr::clearModifiersDown()
{
    shiftDown = false;
    ctrlDown = false;
    altDown = false;
}

void OgreGFX::UIMgr::createInputSystem()
{
    //Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
    DEBUG(std::cout << "*** Initializing OIS ***" << std::endl;)
    OIS::ParamList pl;
    size_t windowHnd = 0;
    std::ostringstream windowHndStr;

    renderWindow->getCustomAttribute("WINDOW", &windowHnd);
    windowHndStr << windowHnd;
    pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));


#if defined OIS_LINUX_PLATFORM
    pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string("false")));
    pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string("false")));
    pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
    pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
#elif defined OIS_WIN32_PLATFORM
    pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
    pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCUSIVE")));
    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
    pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
#endif


    inputManager = OIS::InputManager::createInputSystem(pl);

    keyboard = static_cast<OIS::Keyboard*> (inputManager->createInputObject(OIS::OISKeyboard, true));
    mouse = static_cast<OIS::Mouse*> (inputManager->createInputObject(OIS::OISMouse, true));
    mouse->capture();
    ms = mouse->getMouseState();
    ms.width = gfx->mWindow->getWidth();
    ms.height = gfx->mWindow->getHeight();

    mouse->setEventCallback(this);
    keyboard->setEventCallback(this);

    //Set initial mouse clipping size
    windowResized(renderWindow);

    //Register as a Window listener
    Ogre::WindowEventUtilities::addWindowEventListener(renderWindow, this);

    //mRoot->addFrameListener(this); Added in createInputSystem in GraphicsInteractionManager
}

void OgreGFX::UIMgr::DebugDrawTest()
{
    for (int i = 0; i < 5; ++i)
    {
        for (int j = 0; j < 5; j++)
        {
            for (int k = 0; k < 5; k++)
            {
                Ogre::AxisAlignedBox box(Ogre::Vector3(i * 10.0f + 2.0f, j * 10.0f + 2.0f, k * 10.0f + 2.0f),
                                         Ogre::Vector3((i + 1) * 10.0f - 2.0f, (j + 1) * 10.0f - 2.0f, (k + 1) * 10.0f - 2.0f));
                DebugDrawer::getSingleton().drawCuboid(box.getAllCorners(),
                                                       Ogre::ColourValue(51.0f * i / 255.0f, 51.0f * j / 255.0f, 51.0f * k / 255.0f), true);
            }
        }
    }
    //DebugDrawer::getSingletonPtr()->build();
}

bool OgreGFX::UIMgr::frameStarted(const Ogre::FrameEvent& evt)
{
    //DebugDrawTest();
    //drawSelectionCircles();
    decorateSelectedEntities();
    drawUnderMouseCircle();

    DebugDrawer::getSingletonPtr()->build(); //One build to draw all the debug objects

    DEBUG(std::cout << renderWindow->getAverageFPS() << std::endl;)
    return true;
}

bool OgreGFX::UIMgr::frameEnded(const Ogre::FrameEvent& evt)
{
    DebugDrawer::getSingletonPtr()->clear();
    bars.ClearVertices();
    //  for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it){
    //          FastEcslent::Entity * ent = gfx->engine->entityMgr->ents[(*it)->id];
    //          if (fabs(ent->attractivePotential) < 10 ) {
    //                  std::cout << "Potential vector length, attractive Potential: " << ent->potentialVec.length() << ", "
    //                                  << ent->attractivePotential << std::endl;
    //          }
    //  }
    return true;
}

bool mouseDidScroll(int z)
{
    return (z < -1.0 || z > 1.0);
}

bool OgreGFX::UIMgr::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
    if (renderWindow->isClosed())
        return false;

    //Need to capture/update each device
    keyboard->capture();
    mouse->capture();

    cameraMgr->frameRenderingQueued(evt); // if dialog isn't up, then update the camera

    return true;
}

void OgreGFX::UIMgr::checkSetModifiers(const OIS::KeyEvent &arg, bool value)
{
    if (arg.key == OIS::KC_LSHIFT || arg.key == OIS::KC_RSHIFT)
    {
        shiftDown = value;

    }
    else if (arg.key == OIS::KC_LCONTROL || arg.key == OIS::KC_RCONTROL)
    {
        ctrlDown = value;

    }
    else if (arg.key == OIS::KC_LMENU || arg.key == OIS::KC_RMENU)
    {
        altDown = value;

    }

}

bool OgreGFX::UIMgr::keyPressed(const OIS::KeyEvent &arg)
{
    if (arg.key == OIS::KC_ESCAPE)
    {
        shutDown = true;
        //return false;
    }
    DEBUG(std::cout << "Key pressed: " << arg.key << std::endl;)
    checkSetModifiers(arg, true);

    //  else if (arg.key == OIS::KC_F12) {
    //buildCubes();
    //}

    // Will need to check if camera related keys were pressed.
    // if a camera related key is pressed:
    cameraMgr->injectKeyDown(arg);
    // else if a registered key combo is pressed:
    //call key handler
    //else
    // do nothing

    callKeyHandlers(arg);
    DEBUG(std::cout << "Control down is: " << ctrlDown << std::endl;)
    controlGroupsHandler->checkHandleControlGroupKeys(ctrlDown, arg.key);

    return true;
}

bool OgreGFX::UIMgr::keyReleased(const OIS::KeyEvent &arg)
{
    checkSetModifiers(arg, false);
    cameraMgr->injectKeyUp(arg);
    return true;
}

bool OgreGFX::UIMgr::mouseMoved(const OIS::MouseEvent &arg)
{
    if (selectingNow)
    {
        volumeSelectingNow = true;
        ms = mouse->getMouseState();
        stopPos.x = ms.X.abs / (float) ms.width;
        stopPos.y = ms.Y.abs / (float) ms.height;
        selectionBox->setCorners(startPos, stopPos);
    }
    else if (mouseDidScroll(arg.state.Z.rel) && !arg.state.buttonDown(OIS::MB_Left) && !arg.state.buttonDown(OIS::MB_Right) && !arg.state.buttonDown(OIS::MB_Middle))
    {
        cameraMgr->handleMouseScrollCameraZoom(arg);
    }
    //else if ()
    this->gfx->widgetMgr->mouseOverButton(arg);
    return true;
}

//-------------------------Manage Selection ---------------------------------------------

void OgreGFX::UIMgr::decorateSelectedEntities()
{
    Ogre::Vector3 pos;
    Ogre::Vector3 start;
    Ogre::Vector3 end;
    float selectionCircleRadius = 100.0f;
    FastEcslent::Entity* ent;
    int entId;
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        pos = (*it)->node->getPosition();
        Ogre::Vector3 cpos = Ogre::Vector3(pos.x, pos.y + 1, pos.z);
        selectionCircleRadius = gfx->engine->entityMgr->ents[(*it)->id]->length;
        DebugDrawer::getSingleton().drawCircle(cpos, selectionCircleRadius, FastEcslent::NCircleSegments, Ogre::ColourValue(0.5f, 0.5f, 0.9f, 0.2f), true);

        entId = (*it)->id;
        ent = gfx->engine->entityMgr->ents[entId];
        start = ent->pos;

        if (ent->entityClass != FastEcslent::STATIC)
        {
            float lineLength = ent->length * (1.0 + (ent->speed / ent->speedRange));
            DebugDrawer::getSingleton().drawAngleLine(cpos, Ogre::Radian(ent->heading), lineLength, Ogre::ColourValue(1.0f, 1.0f, 0.0f, 1.0));
            lineLength = ent->length * (1.0 + ent->desiredSpeed / ent->speedRange);
            DebugDrawer::getSingleton().drawAngleLine(cpos, Ogre::Radian(ent->desiredHeading), lineLength, Ogre::ColourValue(1.0f, 1.0f, 1.0f, 0.5));
        }
        Ogre::Vector3 leftPoint = Ogre::Vector3(cpos.x - FastEcslent::healthLineLength / 2, cpos.y, cpos.z - ent->length);
        Ogre::Vector3 rightPoint = Ogre::Vector3(cpos.x + FastEcslent::healthLineLength / 2, cpos.y, cpos.z - ent->length);
        DebugDrawer::getSingleton().drawLine(leftPoint, rightPoint, Ogre::ColourValue(1.0f, 0.0f, 0.0f, 0.5f));
        DEBUG(std::cout << "Hit points: " << ent->weapon->hitpoints << " Max Hit Points: " << gfx->engine->weaponMgr->maxHitpoints[ent->entityType] << std::endl;)
        float healthNow = FastEcslent::healthLineLength * ent->weapon->hitpoints / gfx->engine->weaponMgr->maxHitpoints[ent->entityType];
        rightPoint.x = leftPoint.x + healthNow;
        DebugDrawer::getSingleton().drawLine(leftPoint, rightPoint, Ogre::ColourValue(0.0f, 1.0f, 0.0f, 0.5f));


        bars.percent = 100.0 * (ent->weapon->hitpoints / gfx->engine->weaponMgr->maxHitpoints[ent->entityType]);
        bars.Draw(Ogre::Vector3(pos.x, pos.y + 1, pos.z - selectionCircleRadius));


        // Debug potential fields
        //DebugDrawer::getSingleton().drawAngleLine(cpos, Ogre::Radian(ent->potentialVec.angleBetween(Ogre::Vector3::UNIT_X)), ent->potentialVec.length() * 100, Ogre::ColourValue(1.0f, 0.0f, 0.0f, 1.0));
        //DebugDrawer::getSingleton().drawLine(cpos, cpos + (ent->potentialVec * 100), Ogre::ColourValue(1.0f, 0.0f, 0.0f, 1.0));
    }

}


//void OgreGFX::UIMgr::drawSelectionCircles(){
//      Ogre::Vector3 pos;
//
//      for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it){
//              pos = (*it)->node->getPosition();
//              Ogre::Vector3 cpos = Ogre::Vector3(pos.x, pos.y+1, pos.z);
//              //DebugDrawer::getSingleton().drawCircle((*it)->node->getPosition(), 50.0f, 8, Ogre::ColourValue(255.0f, 255.0f, 255.0f), true );
//              //DebugDrawer::getSingleton().drawCircle(cpos, 50.0f, 8, Ogre::ColourValue(255.0f, 255.0f, 255.0f), true );
//              float radius = gfx->engine->entityMgr->ents[(*it)->id]->length;
//              DebugDrawer::getSingleton().drawCircle(cpos, radius, FastEcslent::NCircleSegments, Ogre::ColourValue(0.0f, 1.0f, 0.0f, 0.5f), true );
//      }
//}

void OgreGFX::UIMgr::drawUnderMouseCircle()
{
    Ogre::Vector3 pos;
    Ogre::Vector3 newPos;
    std::pair<int, Ogre::Vector3> underMouse;
    float radius;
    int id;
    underMouse = entIndexUnderMouse();
    if (underMouse.first >= 0 && underMouse.first < gfx->nGFXNodes)
    {
        DEBUG(std::cout << "Found an ent under mouse" << "\n";)
        id = gfx->gfxNodes[underMouse.first].id;
        pos = gfx->engine->entityMgr->ents[id]->pos;
        newPos = Ogre::Vector3(pos.x, pos.y + 1, pos.z);
        radius = gfx->engine->entityMgr->ents[id]->length;
        DebugDrawer::getSingleton().drawCircle(newPos, radius * 1.5, FastEcslent::NCircleSegments, Ogre::ColourValue(0.0f, 0.0f, 1.0f, 1.0f), false);
    }
}

std::pair<int, Ogre::Vector3> OgreGFX::UIMgr::entIndexUnderMouse()
{
    OIS::MouseState ms;
    ms = mouse->getMouseState();
    return entIndexUnderMouse(ms);
}

std::pair<int, Ogre::Vector3> OgreGFX::UIMgr::entIndexUnderMouse(const OIS::MouseEvent &arg)
{
    OIS::MouseState ms;
    ms = mouse->getMouseState();
    return entIndexUnderMouse(ms);
}

std::pair<bool, Ogre::Vector3> OgreGFX::UIMgr::getMouseWorldPos(const OIS::MouseState &arg)
{
    Ogre::Vector3 pos = Ogre::Vector3::NEGATIVE_UNIT_Y;
    Ogre::Ray mouseRay = camera->getCameraToViewportRay(arg.X.abs / (float) ms.width, arg.Y.abs / (float) ms.height);

    std::pair<bool, float> result = mouseRay.intersects(gfx->oceanSurface);
    if (result.first)
    {
        pos = mouseRay.getPoint(result.second);
    }
    //result.second = mouseRay.getPoint(result.second);
    return std::pair<bool, Ogre::Vector3 > (result.first, pos);

}

std::pair<int, Ogre::Vector3> OgreGFX::UIMgr::entIndexUnderMouse(const OIS::MouseState &arg)
{

    int index = -1;
    std::pair<bool, Ogre::Vector3> mousePos = getMouseWorldPos(arg);
    //Ogre::Vector3 pos = Ogre::Vector3::NEGATIVE_UNIT_Y;
    Ogre::Ray mouseRay = camera->getCameraToViewportRay(arg.X.abs / (float) ms.width, arg.Y.abs / (float) ms.height);
    //this->raySceneQuery->setRay(mouseRay);
    std::pair<bool, float> result = mouseRay.intersects(gfx->oceanSurface);
    if (result.first)
    {
        this->posUnderMouse = mouseRay.getPoint(result.second);
        //this->posUnderMouse = pos;
        float minDistanceSquared = FLT_MAX;
        float distanceSquared;
        // find ent that is 1. Selectable && 2. Within threshold distance && 3. Nearest to mouse cursor
        for (int i = 0; i < gfx->nGFXNodes; i++)
        {
            if (gfx->gfxNodes[i].selectable)
            {
                distanceSquared = this->posUnderMouse.squaredDistance(gfx->gfxNodes[i].node->getPosition());
                if (distanceSquared < selectionDistanceSquaredThreshold)
                {
                    if (distanceSquared < minDistanceSquared)
                    {
                        index = i;
                        minDistanceSquared = distanceSquared;
                    }
                }
            }
        }
    }
    return std::pair<int, Ogre::Vector3 > (index, this->posUnderMouse);
}

void OgreGFX::UIMgr::selectEntity(int index)
{
    currentSelections.push_back(&gfx->gfxNodes[index]); // add node to empty or non-empty list
    //gfx->gfxNodes[index].node->showBoundingBox(true);   // and show boundingbox
    //gfx->engine->entityMgr->ens[gfxNode.id] is entity
}

void OgreGFX::UIMgr::handleSingleSelection(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{

    if (volumeSelectingNow) return;
    std::pair<int, Ogre::Vector3> result = entIndexUnderMouse(arg);
    int index = result.first;
    // Found an ent or none
    if (index >= 0 && index < gfx->nGFXNodes)
    { //if something is near enough the cursor to be selected
        if (!shiftDown)
        { // if it is not to be added to the selection
            clearSelectionsAndUpdateFEEngine(); //clear currently selected
        }
        selectEntity(index);

    }
    else
    { //None: nothing close enough to be selected, so clear selections
        clearSelectionsAndUpdateFEEngine();
    }
    updateFEEngineWithSelections();
}

FastEcslent::Group* OgreGFX::UIMgr::groupFromSelections()
{

    FastEcslent::Entity * ents[FastEcslent::MaxEnts];
    int i = 0;
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        ents[i++] = gfx->engine->entityMgr->ents[(*it)->id];
    }
    FastEcslent::Group* group = gfx->engine->groupMgr->createGroup(ents, i);

    //group->addMember(gfx->engine->entityMgr->ents[(*it)->id]);
    return group;
}

void OgreGFX::UIMgr::handleVolumeSelection(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{

    startPos.x = arg.state.X.abs / (float) ms.width;
    startPos.y = arg.state.Y.abs / (float) ms.height;
    stopPos = startPos;
    selectingNow = true;
    selectionBox->clear();
    selectionBox->setVisible(true);
}

void OgreGFX::UIMgr::printCurrentSelections()
{
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        DEBUG(std::cout << (*it)->id << ", ";)
    }
    DEBUG(std::cout << std::endl;)
    //  for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); it++){
    //          std::cout << (*it)->id << ", ";
    //  }
    DEBUG(std::cout << std::endl;)
}

void OgreGFX::UIMgr::updateFEEngineWithSelections()
{
    boost::mutex::scoped_lock scoped_lock(selectionUpdateLock);
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        gfx->engine->selectionMgr->select((*it)->id);
    }

    if (currentSelections.size() == 0)
    {
        gfx->widgetMgr->deactivateMenu();
    }
    else if (currentSelections.size() == 1)
    {
        gfx->widgetMgr->activateMenu(gfx->engine->entityMgr->ents[(*currentSelections.begin())->id]->entityType);

    }
    else
    {
        gfx->widgetMgr->activateMenu(FastEcslent::NENTITYTYPES);
    }
}

void OgreGFX::UIMgr::clearSelectionsAndUpdateFEEngine()
{
    boost::mutex::scoped_lock scoped_lock(selectionUpdateLock);
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        //boost::mutex::scoped_lock scoped_lock(selectionUpdateLock);
        gfx->engine->selectionMgr->unselect((*it)->id);
    }

    currentSelections.clear();
}

void swap(float &x, float &y)
{
    float tmp = x;
    x = y;
    y = tmp;
}

void OgreGFX::UIMgr::doVolumeSelection(const Ogre::Vector2& first, const Ogre::Vector2& second)
{

    float left = first.x, right = second.x, top = first.y, bottom = second.y;
    if (left > right) swap(left, right);
    if (top > bottom) swap(top, bottom);
    if ((right - left) * (bottom - top) < 0.01) return;

    Ogre::Ray topLeft = camera->getCameraToViewportRay(left, top);
    Ogre::Ray topRight = camera->getCameraToViewportRay(right, top);
    Ogre::Ray bottomLeft = camera->getCameraToViewportRay(left, bottom);
    Ogre::Ray bottomRight = camera->getCameraToViewportRay(right, bottom);

    Ogre::PlaneBoundedVolume vol;
    vol.planes.push_back(Ogre::Plane(topLeft.getPoint(3), topRight.getPoint(3), bottomRight.getPoint(3))); //front (closest to cam) plane
    vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), topLeft.getPoint(10), topRight.getPoint(10))); //top plane
    vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), bottomLeft.getPoint(10), topLeft.getPoint(10))); //left plane
    vol.planes.push_back(Ogre::Plane(bottomLeft.getOrigin(), bottomRight.getPoint(10), bottomLeft.getPoint(10))); //bottom Plane
    vol.planes.push_back(Ogre::Plane(topRight.getOrigin(), topRight.getPoint(10), bottomRight.getPoint(10))); //right Plane

    Ogre::PlaneBoundedVolumeList volList;
    volList.push_back(vol);

    volQuery->setVolumes(volList);
    Ogre::SceneQueryResult result = volQuery->execute();
    clearSelectionsAndUpdateFEEngine();

    Ogre::SceneQueryResultMovableList::iterator iter; // for some reason the last sceneNode is always wrong
    int n = result.movables.size(); //have to throw away last item in iterator. I don't know why?
    //  int i = 0;                      //ToDo -> fix iterator, why is it n-1?
    // The issue is std::map with returns an iterator that points to the end of the map if the key is not in the map.
    //Causes all kinds of strange behavior
    DEBUG(std::cout << "Number of movables: " << n << std::endl;)

    for (iter = result.movables.begin(); iter != result.movables.end(); ++iter)
    {
        //for(iter = result.movables.begin(); iter != result.movables.end(); ++iter){
        //std::cout << gfx->sceneNodeToEntIdMap[(*iter)->getParentSceneNode()] << std::endl;
        if (gfx->sceneNodeToEntIdMap.find((*iter)->getParentSceneNode()) != gfx->sceneNodeToEntIdMap.end())
        {
            selectEntity(gfx->sceneNodeToEntIdMap[(*iter)->getParentSceneNode()]); //why parent scene node?
        }
    }
    updateFEEngineWithSelections();
}
//-------------------------End Manage Selection ---------------------------------------------

//------------------------Handle Commands------------------------------------------------

void OgreGFX::UIMgr::CommandMaintainAttack(int i)
{
    DEBUG(std::cout << "MaintainAttacking: (" << gfx->engine->entityMgr->ents[i]->uiname << ")" << std::endl;)
}

void OgreGFX::UIMgr::CommandGatherOrPFMove(int i)
{
    DEBUG(std::cout << "Gathing (" << gfx->engine->entityMgr->ents[i]->uiname << ")" << std::endl;)
        FastEcslent::Entity * ent;
        for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
        {
                ent = gfx->engine->entityMgr->ents[(*it)->id];
                if (ent->entityClass == FastEcslent::STATIC)   //buildings, continue
                {
                        continue;
                }else if (ent->entityType == FastEcslent::SCV){//scvs, gathering
                        FastEcslent::setGatherForEnt(ent, gfx->engine->entityMgr->ents[i], shiftDown);
                }else {  //units other than scv, move to the mineral
                        FastEcslent::setPotentialMoveForEnt(ent, gfx->engine->entityMgr->ents[i]->pos, shiftDown);
                }
        }
}

void OgreGFX::UIMgr::CommandPotentialFieldsMove(Ogre::Vector3 pos)
{
    DEBUG(std::cout << "Potential Fields: Moving to: (" << pos.x << ", " << pos.z << ")" << std::endl;)
    FastEcslent::Entity * ent;
    for (std::list<OgreGFX::GFXNode*>::iterator it = currentSelections.begin(); it != currentSelections.end(); ++it)
    {
        ent = gfx->engine->entityMgr->ents[(*it)->id];
        if (ent->entityClass == FastEcslent::STATIC)
        {
            continue;
        }
        FastEcslent::setPotentialMoveForEnt(ent, pos, shiftDown);
    }
}

void OgreGFX::UIMgr::CommandMove(Ogre::Vector3 pos)
{
    DEBUG(std::cout << "Moving to: (" << pos.x << ", " << pos.z << ")" << std::endl;)

    if (currentSelections.size() <= 0) return;

    if (currentSelections.size() > 1)
    {
        FastEcslent::Group* group = groupFromSelections();
        for (int i = 0; i < group->nEntitiesInGroup; i++)
        {
            group->members[i]->ai->commands.clear();
        }
        group->setLeaderByIndex(0);
        FastEcslent::GroupAI* gai = new FastEcslent::GroupAI(group, FastEcslent::GROUPAI);
        FastEcslent::GroupTarget* gt = new FastEcslent::GroupTarget;
        gt->target.location = pos;
        FastEcslent::Flock* flock = new FastEcslent::Flock(group, gt);
        //flock->changeLeadership(FastEcslent::MostMassive);
        DEBUG(std::cout << "Left Shift: " << shiftDown << std::endl;)
        if (shiftDown)
        {
            DEBUG(std::cout << "Adding flock" << std::endl;)
            FastEcslent::addMoveForEnt(gfx->engine->entityMgr->ents[currentSelections.front()->id], pos); //commandHelper
            //gai->addCommand(flock);
        }
        else
        {
            FastEcslent::setMoveForEnt(gfx->engine->entityMgr->ents[currentSelections.front()->id], pos); //commandHelper
            //gai->setCommand(flock);
        }
        group->addAspect(gai);
    }
    else
    {
        FastEcslent::Entity * ent = gfx->engine->entityMgr->ents[currentSelections.front()->id];
        boost::mutex::scoped_lock scoped_lock(selectionUpdateLock);
        FastEcslent::setPotentialMoveForEnt(ent, pos, shiftDown);
    }
}

void OgreGFX::UIMgr::handleCommand(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
    std::pair<int, Ogre::Vector3> result = entIndexUnderMouse(arg);
    int index = result.first;

    if (index >= 0 && index < gfx->nGFXNodes)
    { //do_maintain()
        if(gfx->engine->entityMgr->ents[index]->entityType == FastEcslent::MINERALS){
                CommandGatherOrPFMove(index);
        }else{
                CommandMaintainAttack(index);
        }
    }
    else
    {
        CommandPotentialFieldsMove(result.second);
    }
    DEBUG(std::cout << "MousePos: " << getMouseWorldPos(arg.state).second << std::endl;)
    DEBUG(std::cout << "Game State: ";)
    for (int i = 0; i < this->gfx->engine->entityMgr->nEnts; i++)
    {
        DEBUG(std::cout << this->gfx->engine->entityMgr->ents[i]->entityType << "," << this->gfx->engine->entityMgr->ents[i]->pos.x << "," << this->gfx->engine->entityMgr->ents[i]->pos.y << "," << this->gfx->engine->entityMgr->ents[i]->pos.z << " || ";)

    }
    DEBUG(std::cout << std::endl;)

}
//------------------------Handle Mouse Commands------------------------------------------------

bool OgreGFX::UIMgr::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
    DEBUG(std::cout << "Input System: Mouse Pressed (" << arg.state.X.abs << ", " << arg.state.Y.abs << ")" << std::endl;)
    if (this->gfx->widgetMgr->mouseOverOverlay(arg)) return true;
    if (id == OIS::MB_Left)
    { //select
        handleSingleSelection(arg, id);
        handleVolumeSelection(arg, id);
    }
    else if (id == OIS::MB_Right)
    {
        handleCommand(arg, id);
    }
    //callMouseHandlers(arg, id);
    return true;
}

bool OgreGFX::UIMgr::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
{
    if (id == OIS::MB_Left)
    {
        doVolumeSelection(startPos, stopPos);
        selectingNow = false;
        volumeSelectingNow = false;
        selectionBox->setVisible(false);
    }
    callMouseHandlers(arg, id);
    return true;
}

//----------------------------------------Handle key registration-----------------------------------

bool OgreGFX::UIMgr::registerKeyHandler(const std::set<OIS::KeyCode> *modifiers, const OIS::KeyCode key, OgreGFX::KeyHandler *handler)
{
    OgreGFX::KeySet keySet = OgreGFX::KeySet(modifiers, key);
    std::string keySetString = keySet.toString(); //convertKeySetToString(keySet);
    //keyHandlers[keySetString] = handler; // Map should make it easier to select handler to run
    keyHandlers[keySetString].push_back(handler); // Map should make it easier to select handler to run
    return true;
}

bool OgreGFX::UIMgr::registerMouseHandler(const std::set<OIS::KeyCode> *modifiers, const OIS::MouseButtonID buttonId, OgreGFX::MouseHandler *handler)
{
    OgreGFX::MouseButtonKeySet mbKeySet = OgreGFX::MouseButtonKeySet(modifiers, buttonId);
    std::string mouseButtonKeySetString = mbKeySet.toString(); //convertMouseButtonKeySetToString(mbKeySet);
    //mouseHandlers[mouseButtonKeySetString] = handler;
    mouseHandlers[mouseButtonKeySetString].push_back(handler);
    return true;
}

// --------------------------------------Call key/mouse Handlers-------------------------------------------

std::set<OIS::KeyCode> *OgreGFX::UIMgr::makeModifiersSet()
{
    std::set<OIS::KeyCode> *mods = new std::set<OIS::KeyCode > ();
    if (shiftDown)
        mods->insert(OIS::KC_LSHIFT);
    if (altDown)
        mods->insert(OIS::KC_LMENU);
    if (ctrlDown)
        mods->insert(OIS::KC_LCONTROL);
    return mods;
}

std::string OgreGFX::UIMgr::modifierKeyHash(const OIS::KeyCode keyCode)
{

    std::set<OIS::KeyCode> *mods = makeModifiersSet();
    OgreGFX::KeySet ks = OgreGFX::KeySet(mods, keyCode);
    return ks.toString();
}

std::string OgreGFX::UIMgr::modifierKeyMouseHash(const OIS::MouseButtonID id)
{

    std::set<OIS::KeyCode> *mods = makeModifiersSet();
    OgreGFX::MouseButtonKeySet mbks = OgreGFX::MouseButtonKeySet(mods, id);
    return mbks.toString();
}

bool OgreGFX::UIMgr::callKeyHandlers(const OIS::KeyEvent &arg)
{

    std::string keySetHash = modifierKeyHash(arg.key);
    if (this->keyHandlers.count(keySetHash) > 0)
    {
        for (std::list<KeyHandler *>::iterator khi = this->keyHandlers[keySetHash].begin(); khi != this->keyHandlers[keySetHash].end(); ++khi)
        {
            (*khi)->handleKeyEvent();
        }
        //this->keyHandlers[keySetHash]->handleKeyEvent();
        return true;
    }
    return false;
}

bool OgreGFX::UIMgr::callMouseHandlers(const OIS::MouseEvent &arg, const OIS::MouseButtonID id)
{

    std::string mouseButtonKeySetHash = modifierKeyMouseHash(id);
    if (this->mouseHandlers.count(mouseButtonKeySetHash) > 0)
    {
        for (std::list<MouseHandler *>::iterator mhi = this->mouseHandlers[mouseButtonKeySetHash].begin(); mhi != this->mouseHandlers[mouseButtonKeySetHash].end(); ++mhi)
        {
            (*mhi)->handleMouseEvent(arg);
        }
        //this->mouseHandlers[mouseButtonKeySetHash]->handleMouseEvent(arg);
        return true;
    }
    return false;
}
//--------------------------------------------------------------------------------------------------

//void OgreGFX::UIMgr::createNewEntity(FastEcslent::Identity id){
//
//}

//--------------------------------------------------------------------------------------------------

//Adjust mouse clipping area

void OgreGFX::UIMgr::windowResized(Ogre::RenderWindow* rw)
{
    unsigned int width, height, depth;
    int left, top;
    rw->getMetrics(width, height, depth, left, top);

    const OIS::MouseState &ms = mouse->getMouseState();
    ms.width = width;
    ms.height = height;
}

OgreGFX::UIMgr::~UIMgr()
{

    kill();
}

void OgreGFX::UIMgr::kill()
{
    //sceneManager->destroyQuery(volQuery);



    if (selectionBox)
    {
        //delete selectionBox;
    }

    delete DebugDrawer::getSingletonPtr();

    if (cameraMgr)
    {
        delete cameraMgr;
        cameraMgr = 0;
    }
    if (inputManager)
    {
        inputManager->destroyInputObject(mouse);
        inputManager->destroyInputObject(keyboard);

        OIS::InputManager::destroyInputSystem(inputManager);
        inputManager = 0;
    }
    if (renderWindow)
    {
        Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow, this);
        //if(renderWindow) windowClosed(renderWindow);
    }


}

void OgreGFX::UIMgr::windowClosed(Ogre::RenderWindow* rw)
{
    //Only close for window that created OIS (the main window in these demos)
    if (rw == renderWindow)
    {
        kill();
    }
}

//void OgreGFX::UIMgr::buttonHit(OgreBites::Button* button)
//{
//
//}

---