flock.cpp

#include "flock.h"
#include "boid.h"
#include "debug.h"
#include "random.h"

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

extern ITimer* timer;
extern Debug* dbg;

Flock::Flock(IrrlichtDevice* d,
        f32 size,
        const c8* boidMeshFile,
        ISceneNode* parent,
        s32 id,
        const vector3df& position)
: ISceneNode(parent, d->getSceneManager(), id, position)
{
    dbg->log("create Flock");
    device = d;

        box.reset(position);

        Random random(timer->getRealTime());
        for (s32 i=0; i<size; i++)
        {
                vector3df pos(random.randfloat(-250, 250),
                        random.randfloat(10, 500),
                        random.randfloat(-250, 250) );
        addBoid(position + pos, boidMeshFile);
        }
}

Flock::~Flock()
{
    //dtor
    removeBoids();
    device = NULL;
    dbg->log("Flock deleted");
}

void Flock::update(irr::u32 deltaTime)
{
    list<Boid*>::Iterator it = boids.begin();
    box.reset(box.getCenter());
    for (; it != boids.end(); ++it)
    {
        (*it)->update(deltaTime);
        // update boundingbox, keep Boids relative position in mind.
        box.addInternalPoint((*it)->position - ISceneNode::getPosition());
    }
}

Boid* Flock::addBoid(vector3df pos, const c8* boidMeshFile)
{
    Boid* b = new Boid(device, boidMeshFile);
    boids.push_back(b);
    b->position = pos;
    box.addInternalPoint(pos.X, pos.Y, pos.Z);
    return b;
}

void Flock::removeBoid(Boid* b)
{
    list<Boid*>::Iterator it = boids.begin();
    for (; it != boids.end(); ++it)
    {
        if ((*it) == b)
        {
            delete (*it);
            boids.erase(it);
            return;
        }
    }
    dbg->log("Flock::removeBoid() cannot find Boid to delete");
}

void Flock::removeBoids()
{
    list<Boid*>::Iterator it = boids.begin();
    for (; it != boids.end(); ++it)
    {
        delete (*it);
    }
    boids.clear();
}

s32 Flock::getBoidCount()
{
    return boids.getSize();
}

list<Boid*>& Flock::getBoidList(void)
{
    return boids;
}

void Flock::render()
{
    IVideoDriver* driver = device->getVideoDriver();
    driver->setMaterial(material);
        //driver->setTransform(ETS_WORLD, AbsoluteTransformation);
        //driver->draw3DBox(box);
}

const aabbox3d<f32>& Flock::getBoundingBox() const
{
        return box;
}

void Flock::OnPreRender()
{
        if (IsVisible)
        {
                SceneManager->registerNodeForRendering(this);
        }
        ISceneNode::OnPreRender();
}

video::SMaterial& Flock::getMaterial(s32 i)
{
    if (i > 0)
    {
        dbg->log("Flock::getMaterial() cannot access material", i);
    }
        return material;
}

s32 Flock::getMaterialCount()
{
        return 1;
}

void Flock::setScale(f32 scale)
{
    list<Boid*>::Iterator it = boids.begin();
    for (; it != boids.end(); ++it)
    {
        (*it)->setScale(scale);
    }
}

void Flock::setSeparationWeight(s32 weight)
{
    separationWeight = weight;
}

s32 Flock::getSeparationWeight()
{
    return separationWeight;
}

void Flock::setAlignmentWeight(s32 weight)
{
    alignmentWeight = weight;
}

s32 Flock::getAlignmentWeight()
{
    return alignmentWeight;
}

void Flock::setCohesionWeight(s32 weight)
{
    cohesionWeight = weight;
}

s32 Flock::getCohesionWeight()
{
    return cohesionWeight;
}

void Flock::setNeighborRadius(s32 radius)
{
    neighborRadius = radius;
}

s32 Flock::getNeighborRadius()
{
    return neighborRadius;
}

void Flock::setTarget(vector3df target)
{
    seekTarget = target;
}

vector3df Flock::getTarget()
{
    return seekTarget;
}

void Flock::setSeekTargetWeight(s32 weight)
{
    seekTargetWeight = weight;
}

s32 Flock::getSeekTargetWeight()
{
    return seekTargetWeight;
}

void Flock::setTornadoWeight(s32 weight)
{
    tornadoWeight = weight;
}

s32 Flock::getTornadoWeight()
{
    return tornadoWeight;
}

---