Space.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Physics/Space.h>
#include <PVLE/Entity/3DPhy.h>
#include <PVLE/Physics/Visitor.h>
#include <PVLE/Util/Assert.h>
//#include <boost/cast.hpp>

namespace Physics {


Space::Space(const Space & v, UINT opts, IGeomCollisionContainer * pGeomsContainer, TDuplicatedBodiesMap * pDuplicatedBodies)
    : typeInfo(v.typeInfo), collided(false)
{
    if (pGeomsContainer && !(opts & COPY_CHILDREN)) LOG_WARN << "Giving a collision container for a shallow space copy doesn't make sense (the given container is useless for the copy)." << std::endl;

    init();     // Does the main job of copying (as typeInfo has been copied).

    // Copy geoms and spaces included
    if (opts & COPY_CHILDREN && !v.vGeoms.empty()) {
        BOOST_FOREACH(const AbstractGeom * pAGeom, v.vGeoms)
            add(clone(*pAGeom, opts, pGeomsContainer, pDuplicatedBodies));
    }
}

Space::~Space() {
    // Do not delete ODE space : base class will delete the space, as it is also an ODE geom (an abstract geom in PVLE).
}

void Space::accept(Visitor & v) { v.apply(*this); }

void Space::traverse(Visitor & v) {
    // Traverse all children.
    BOOST_FOREACH(AbstractGeom * pAGeom, vGeoms) pAGeom->accept(v);
}


void Space::add(AbstractGeom * pAbstractGeom) {
//Space * pSpace = pAbstractGeom->asSpace();
//Space * a;
//if (pSpace) {
//  a = pSpace->getParentSpace();
//}

    ASSERT(pAbstractGeom != this);
    if (pAbstractGeom->getParentSpace()) {
        LOG_WARN << "[Performance warn] Cannot add an abstract geom that already has a parent space to another space." << std::endl;
        return;
    }
#ifdef _DEBUG
    ASSERT(vGeoms.insert(pAbstractGeom).second);
#else
    vGeoms.insert(pAbstractGeom);
#endif
    dSpaceAdd(asSpaceId(), pAbstractGeom->id);
//if (pSpace) {
//  a = pSpace->getParentSpace();
//}
}

void Space::add(C3DPhy & r3DPhy) {
    Physics::AbstractGeom * p;
    BOOST_FOREACH(p, r3DPhy.getSpaces()) add(p);
    BOOST_FOREACH(p, r3DPhy.getGeoms()) add(p);
}


void Space::remove(AbstractGeom * pAbstractGeom) {
    ASSERT(vGeoms.find(pAbstractGeom) != vGeoms.end());
    //dSpaceRemove(asSpaceId(), pAbstractGeom->id);     // Useless because AbstractGeom destructor does it.
    vGeoms.erase(pAbstractGeom);
}

void Space::removeAll() {
    //dSpaceClean(asSpaceId());     // Useless because AbstractGeom destructor does dSpaceRemove().
    vGeoms.clear();
}

void Space::remove(C3DPhy & r3DPhy) {
    Physics::AbstractGeom * p;
    BOOST_FOREACH(p, r3DPhy.getGeoms()) remove(p);
    BOOST_FOREACH(p, r3DPhy.getSpaces()) remove(p);
}

bool Space::isInSpace(AbstractGeom * pAbstractGeom) const {
    TListGeoms::const_iterator it = find(vGeoms.begin(), vGeoms.end(), pAbstractGeom);
    return it != vGeoms.end();
}

void Space::init() {
    SpaceTypeInfo::ESpaceType type = typeInfo.getType();
    if (type == SpaceTypeInfo::SIMPLE) initSimple();
    else if (type == SpaceTypeInfo::QUAD) {
        const SpaceTypeInfo::QuadData & data = typeInfo.getQuadData();
        initQuad(data.worldBox, data.center, data.level);
    }
    else if (type == SpaceTypeInfo::HASH) {
        const SpaceTypeInfo::HashData & data = typeInfo.getHashData();
        initHash(data.minLevel, data.maxLevel);
    }
    else {
        ASSERT(type == SpaceTypeInfo::SWEEP_AND_PRUNE);
        initSweepAndPrune(typeInfo.getSweepAndPruneData().axisOrder);
    }

    dSpaceSetCleanup(asSpaceId(), 0);       // Do not delete geoms when space is deleted (will be done on our own).
    dGeomSetData(id, this);     // Back reference
}

void Space::initSimple() {
    id = (dGeomID)dSimpleSpaceCreate(0);
}

void Space::initHash(UINT minLevel, UINT maxLevel) {
    id = (dGeomID)dHashSpaceCreate(0);
    dHashSpaceSetLevels(asSpaceId(), minLevel, maxLevel);
}

void Space::initQuad(osg::Vec3 worldBox, osg::Vec3 center, UINT level) {
    dVector3 _center; toPhyVec3(center, _center);
    dVector3 _box; toPhyVec3(worldBox, _box);
    id = (dGeomID)dQuadTreeSpaceCreate(0, _center, _box, level);
}

void Space::initSweepAndPrune(int axesOrder) {
    id = (dGeomID)dSweepAndPruneSpaceCreate(0, axesOrder);
}

}   // namespace Physics

---