stateflocksimulation.cpp

#include "statemachine.h"
#include "debug.h"
#include "random.h"
#include "fast_atof.h"
#include "flock.h"
#include "boid.h"
#include "flockanimatordefault.h"
#include "gui.h"
#include "terrain.h"
#include "stateflocksimulation.h"

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace gui;

extern StateMachine* sm;
extern Debug* dbg;
extern ITimer* timer;

StateFlockSimulation::StateFlockSimulation(c8* n, IrrlichtDevice* d) : State(n, d)
{
    //ctor
}

StateFlockSimulation::~StateFlockSimulation()
{
    //dtor
}

bool StateFlockSimulation::OnEvent(SEvent event)
{
    if (event.EventType == EET_KEY_INPUT_EVENT)
    {
        if (event.KeyInput.PressedDown)
        {
            switch(event.KeyInput.Key)
            {
                case KEY_ESCAPE:
                {
                    if (guiMesh->isVisible())
                    {
                        guiMesh->setVisible(false);
                        guiFlock->setVisible(false);
                    }
                    else
                    {
                        guiMesh->setVisible(true);
                        guiFlock->setVisible(true);
                    }
                    return true;
                }
            }
        }
    }

    if (event.EventType == EET_GUI_EVENT)
    {
        s32 id = event.GUIEvent.Caller->getID();

        switch(event.GUIEvent.EventType)
        {
            case EGET_BUTTON_CLICKED:
            {
                switch (id)
                {
                    case 101:
                    {
                        if (! device->getGUIEnvironment()->addFileOpenDialog(L"open file"))
                        {
                            dbg->log("openFileDialog() cannot create dialog");
                        }
                        return true;
                    }
                    case 102:
                    {
                        // create new flock
                        addFlock();

                        s32 meshScale = guiMesh->getSliderValue(111);
                        // for each flock
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            // for each boid
                            list<Boid*>::Iterator it = flocks[i]->getBoidList().begin();
                            for (; it != flocks[i]->getBoidList().end(); ++it)
                            {
                                // update boid mesh scale
                                (*it)->setScale(meshScale / 100.0f);
                            }
                        }
                        return true;
                    }
                    case 109:
                    {
                        // delete all flocks
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->remove();
                            flocks[i]->drop();
                        }
                        flocks.clear();
                        return true;
                    }
                    case 199:
                    {
                        sm->pushEvent("STATE_MENU");
                        return true;
                    }
                    default:
                    {
                        dbg->log("StateFlockSimulation::OnEvent() unhandelt event from id", id);
                        return false;
                    }
                }
            }

            case EGET_FILE_SELECTED:
            {
                // create new flock from file open dialog
                IGUIFileOpenDialog* dialog = (IGUIFileOpenDialog*)event.GUIEvent.Caller;
                stringw path(dialog->getFilename());
                guiMesh->setTextFromID(100, path);
                addFlock();
                return true;
            }

            case EGET_SCROLL_BAR_CHANGED:
            {
                switch (id)
                {
                    case 104:
                    {
                        // set new separation for each flock
                        s32 separation = guiFlock->getSliderValue(104);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->setSeparationWeight(separation);
                        }
                        break;
                    }
                    case 106:
                    {
                        // set new alignment for each flock
                        s32 alignment = guiFlock->getSliderValue(106);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->setAlignmentWeight(alignment);
                        }
                        break;
                    }
                    case 108:
                    {
                        // set new cohesion for each flock
                        s32 cohesion = guiFlock->getSliderValue(108);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->setCohesionWeight(cohesion);
                        }
                        break;
                    }
                    case 113:
                    {
                        // set new radius of neighbor searchness for each flock
                        s32 radius = guiFlock->getSliderValue(113);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->setNeighborRadius(radius * 10);
                        }
                        break;
                    }
                    case 115:
                    {
                        // set new target seekness
                        s32 seekness = guiFlock->getSliderValue(115);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            flocks[i]->setSeekTargetWeight(seekness);
                        }
                        break;
                    }
                    case 111:
                    {
                        // set new sclae of mesh for each boid for each flock
                        s32 meshScale = guiMesh->getSliderValue(111);
                        for (u32 i=0; i<flocks.size(); i++)
                        {
                            list<Boid*>::Iterator it = flocks[i]->getBoidList().begin();
                            for (; it != flocks[i]->getBoidList().end(); ++it)
                            {
                                (*it)->setScale(meshScale / 100.0f);
                            }
                        }
                        break;
                    }
                    default:
                    {
                        dbg->log("StateFlockSimulation::OnEvent() unhandelt event from id", id);
                        return false;
                    }
                }
                return true;
            }
        }
    }

    if (event.EventType == EET_MOUSE_INPUT_EVENT)
    {
        switch(event.MouseInput.Event)
        {
            case EMIE_LMOUSE_PRESSED_DOWN:
            {
                return false;
            }
            case EMIE_RMOUSE_PRESSED_DOWN:
            {
                return false;
            }
            case EMIE_MOUSE_WHEEL:
            {
                f32 speed = event.MouseInput.Wheel;
                moveCamera(speed * 100.0f);
                return true;
            }
        }
    }

    return false;
}

void StateFlockSimulation::render(u32 deltaTime)
{
    device->getVideoDriver()->beginScene(true, true, video::SColor(0,0,150,150));
    device->getSceneManager()->drawAll();

    dbg->show("this is FlockSimulationState");
    dbg->show("roll WHEEL to zoom");
    dbg->show("polyCount", device->getVideoDriver()->getPrimitiveCountDrawn());
    dbg->show("fps", device->getVideoDriver()->getFPS());
    //dbg->show("camPos", camera->getPosition());

    s32 sum = 0;
    for (u32 i=0; i<flocks.size(); i++)
    {
        flocks[i]->update(deltaTime);
        sum += flocks[i]->getBoidCount();
    }
    dbg->show("boidsCount", sum);

    device->getGUIEnvironment()->drawAll();
    device->getVideoDriver()->endScene();

    // camera tracks last added flock
    if (!flocks.empty())
    {
        vector3df flockCenter = flocks.getLast()->getBoundingBox().getCenter();
        camera->setTarget(flockCenter);
    }
}

void StateFlockSimulation::entry()
{
    dbg->log("State", name, "entry");

    // init members

    // create GUI
    guiMesh = new Gui(device, stringc("Mesh"), rect<s32>(20, 220, 200, 430));
    guiMesh->addText(100, "media/fly/satelite40Faces1Texture.3DS");
    guiMesh->addButton(101, "Open mesh file");
    guiMesh->addButton(102, "Create flock");
    guiMesh->addButton(109, "Clear scene");
    guiMesh->addSlider(111, "Meshscale", 16);
    guiMesh->addButton(199, "Exit");

    guiFlock = new Gui(device, stringc("Flock behavior mixer"), rect<s32>(600, 20, 780, 120));
    guiFlock->addSlider(104, "Separation", 36);
    guiFlock->addSlider(106, "Alignment", 0);
    guiFlock->addSlider(108, "Cohesion", 35);
    guiFlock->addSlider(113, "Neighbor_Radius", 10);
    guiFlock->addSlider(115, "Seek_Target", 8);

    // get that messy terrain
    terrain = new Terrain(device, "media/terrain/terrain97_128.bmp", "media/terrain/textur99.bmp", "");

    // create camera
    camera = device->getSceneManager()->addCameraSceneNode();
    camera->setPosition(terrain->getCenter() + vector3df(500, 1500, 500) );
    camera->setRotation(vector3df(60,20,0));

    // create light
    ILightSceneNode* light = device->getSceneManager()->addLightSceneNode(camera);
    light->getLightData().Radius *= 40;

    //device->getCursorControl()->setVisible(false);
    device->getSceneManager()->getActiveCamera()->setFarValue(5000);
}

void StateFlockSimulation::exit()
{
    dbg->log("State", name, "exit");

    // deinit members
    for (u32 i=0; i<flocks.size(); i++)
    {
        flocks[i]->remove();
        flocks[i]->drop();
    }
    flocks.clear();

    delete guiMesh;
    delete guiFlock;
    delete terrain;

    device->getSceneManager()->clear();
}

void StateFlockSimulation::moveCamera(f32 speed)
{
    vector3df start = camera->getPosition();
    vector3df target = camera->getTarget() - start;
    target.normalize();
    camera->setPosition(start + target * speed);
}

void StateFlockSimulation::addFlock()
{
    stringc filePath = guiMesh->getTextFromID(100);
    Flock* f = new Flock(device, 50, filePath.c_str(),
        device->getSceneManager()->getRootSceneNode() );

    // animatorDefault behavior
    f->setSeparationWeight(guiFlock->getSliderValue(104));
    f->setAlignmentWeight(guiFlock->getSliderValue(106));
    f->setCohesionWeight(guiFlock->getSliderValue(108));
    f->setNeighborRadius(guiFlock->getSliderValue(113) * 10);
    f->setTarget(terrain->getCenter() + vector3df(0, 1000, 0) );
    f->setSeekTargetWeight(guiFlock->getSliderValue(115));
    // animatorTornado behavior
    f->setTornadoWeight(1);

    flocks.push_back(f);

/*
    Random random(timer->getRealTime());
    vector3df center(random.randfloat(-40,40), random.randfloat(0,30), random.randfloat(-40,40));
    f32 power = random.randfloat(0.0f, 10.0f);
    FlockAnimatorExplode* animE = new FlockAnimatorExplode(device, center, timer->getTime(), 50000, power);
    f->addAnimator(animE);
    animE->drop();
*/

    FlockAnimatorDefault* flockAnimDefault = new FlockAnimatorDefault(device);
    f->addAnimator(flockAnimDefault);
    flockAnimDefault->drop();
}

---