Geom.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/World.h>
#include <PVLE/Physics/Body.h>
#include <PVLE/Physics/Geom.h>
#include <PVLE/Physics/Space.h>
#include <PVLE/Physics/Contact.h>
#include <PVLE/Physics/GeometryHandlers.h>
#include <PVLE/Physics/Visitor.h>
#include <PVLE/Util/Assert.h>
#include <PVLE/Config.h>

namespace Physics {

Geom::Geom(GeometryHandler * pGeometryHandler, const SurfaceParams & surfaceParams) :
    pGeomH(pGeometryHandler), pContainer(NULL), surface(surfaceParams), gameplayDensity(2000)       // Gameplay density set to concrete (about)
{
    id = pGeomH->create(0);
    dGeomSetData(id, this);
}

void Geom::accept(Visitor & v) { v.apply(*this); }
void Geom::traverse(Visitor & v) {
    if (pBody.valid()) v.apply(*pBody);
}


#ifdef PVLE_PHYSICS_KEEP_DEPRECATED_TRANSFORMS
Geom::Geom() :
    pContainer(NULL), gameplayDensity(2000)     // Gameplay density set to concrete (about)
{}
#endif

Geom::Geom(const Geom & v, UINT opts, IGeomCollisionContainer * pContainer, TDuplicatedBodiesMap * pDuplicatedBodies) :
    pGeomH(NULL), pContainer(pContainer)
{
    pGeomH = v.pGeomH->clone();
    id = pGeomH->create(0);
    dGeomSetData(id, this);

    dGeomSetPosition(id, dGeomGetPositionV(v));
    dGeomSetQuaternion(id, dGeomGetQuaternionV(v));
    if (dGeomIsEnabled(v)) dGeomEnable(*this); else dGeomDisable(*this);

    //setMatrix(v.getMatrix());     // Copy position of each geom
    //if (opts & COPY_BODIES) {
    //  if (v.pBody.valid()) {
    //      setBody(new Body(*(v.pBody)));
    //      pBody->setMatrix(v.pBody->getMatrix());     // Copy position of each body
    //  }
    //  else setBody(NULL);
    //}

    // Duplication of body
    if (opts & COPY_BODIES) {
        const Body * pOriginalBody = v.pBody.get();
        if (!pOriginalBody) {
            // There's no body to duplicate.
            setBody(NULL);
        } else {
            // There's a body to duplicate.
            if (!pDuplicatedBodies) {
                // There's no duplicated bodies collection. Simply duplicate the body.
                setBody(new Body(*pOriginalBody));
            } else {
                // See if the body has already been duplicated.
                TDuplicatedBodiesMap::iterator it = pDuplicatedBodies->find(pOriginalBody);
                if (it != pDuplicatedBodies->end()) setBody(it->second);    // Body already exists in the collection. Do not copy twice, but set the body.
                else {
                    // Body has not been found. Duplicate it and add it to the collection.
                    setBody(new Body(*pOriginalBody));
                    if (pDuplicatedBodies) pDuplicatedBodies->insert( TDuplicatedBody(pOriginalBody, pBody.get()) );
                }
            }

            // Copy geom offset if there's a body
            ASSERT(pBody.valid());
            setOffsetMatrix(v.getOffsetMatrix());
        }
    }

    surface = v.surface;
    gameplayDensity = v.gameplayDensity;

    setMatrix(v.getMatrix());       // Copy position of each geom
}


void Geom::setBody(Body * pBody) {
    this->pBody = pBody;
    if (!pBody) {
        dGeomSetBody(id, 0);
        return;
    }

    dGeomSetBody(id, pBody->id);
    applyHints();
}


void Geom::resetAndApplyHints() {
    if (!pBody) return;
    dBodySetAutoDisableDefaults(*pBody);
    applyHints();
}


void Geom::applyHints() {
    // Override auto-disable settings if necessary
    ASSERT(pGeomH.valid() && pBody.valid());
    UINT flag = pGeomH->getADOverrideFlag();
    if (flag & GeometryHandler::AD_FLAG)          dBodySetAutoDisableFlag(*pBody, pGeomH->getADFlag() ? 1 : 0);
    if (flag & GeometryHandler::AD_LINEAR)        dBodySetAutoDisableLinearThreshold(*pBody, pGeomH->getADLinearThreshold());
    if (flag & GeometryHandler::AD_ANGULAR)       dBodySetAutoDisableAngularThreshold(*pBody, pGeomH->getADAngularThreshold());
    if (flag & GeometryHandler::AD_STEPS)         dBodySetAutoDisableSteps(*pBody, pGeomH->getADSteps());
    if (flag & GeometryHandler::AD_TIME)          dBodySetAutoDisableTime(*pBody, pGeomH->getADTime());
    if (flag & GeometryHandler::AD_SAMPLES_COUNT) dBodySetAutoDisableAverageSamplesCount(*pBody, pGeomH->getADSamplesCount());
}


UINT Geom::collide(Geom * pGeom, UINT nbMaxContacts, Contact * pContacts) {
    return dCollide(id, pGeom->id, nbMaxContacts, &(pContacts[0].geom), sizeof(Contact));
}

}   // namespace Physics

---