PhysicsBody.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_PHYSICS_BODY_H
#define HPL_PHYSICS_BODY_H

#include "hpl1/engine/graphics/GraphicsTypes.h"
#include "hpl1/engine/scene/Entity3D.h"

namespace hpl {

class iPhysicsWorld;
class iCollideShape;
class iPhysicsMaterial;
class iLowLevelGraphics;
class cNode3D;
class cSoundEntity;
class iPhysicsJoint;
class cPhysicsContactData;
class iCharacterBody;

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

class iPhysicsBody;
class iPhysicsBodyCallback {
public:
    virtual ~iPhysicsBodyCallback() {}
    virtual bool OnBeginCollision(iPhysicsBody *apBody, iPhysicsBody *apCollideBody) = 0;
    virtual void OnCollide(iPhysicsBody *apBody, iPhysicsBody *apCollideBody,
                           cPhysicsContactData *apContactData) = 0;
};

typedef Common::List<iPhysicsBodyCallback *> tPhysicsBodyCallbackList;
typedef tPhysicsBodyCallbackList::iterator tPhysicsBodyCallbackListIt;

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

class cSaveData_iCollideShape : public iSerializable {
    kSerializableClassInit(cSaveData_iCollideShape) public : int mType;
    cMatrixf m_mtxOffset;
    cVector3f mvSize;
};

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

kSaveData_ChildClass(iEntity3D, iPhysicsBody) {
    kSaveData_ClassInit(iPhysicsBody) public : cContainerList<cSaveData_iCollideShape> mlstShapes;

    tString msMaterial;

    bool mbBlocksSound;
    bool mbIsCharacter;
    bool mbCollideCharacter;

    cVector3f mvLinearVelocity;
    cVector3f mvAngularVelocity;
    float mfLinearDamping;
    float mfAngularDamping;
    float mfMaxLinearSpeed;
    float mfMaxAngularSpeed;

    float mfMass;

    bool mbEnabled;
    bool mbAutoDisable;
    bool mbContinuousCollision;

    bool mbGravity;

    bool mbCollide;

    virtual iSaveObject *CreateSaveObject(cSaveObjectHandler * apSaveObjectHandler, cGame * apGame);
    virtual int GetSaveCreatePrio();
};

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

struct cPhysicsBody_Buoyancy {
    cPhysicsBody_Buoyancy() : mbActive(false), mfDensity(1),
                              mfLinearViscosity(1), mfAngularViscosity(1) {}

    bool mbActive;

    float mfDensity;
    float mfLinearViscosity;
    float mfAngularViscosity;

    cPlanef mSurface;
};

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

class iPhysicsBody : public iEntity3D {
    typedef iEntity3D super;

public:
    iPhysicsBody(const tString &asName, iPhysicsWorld *apWorld, iCollideShape *apShape);
    virtual ~iPhysicsBody();

    void Destroy();

    virtual void SetMaterial(iPhysicsMaterial *apMaterial) = 0;
    iPhysicsMaterial *GetMaterial();

    cNode3D *GetNode();
    cNode3D *CreateNode();

    iCollideShape *GetShape();

    void AddJoint(iPhysicsJoint *apJoint);
    iPhysicsJoint *GetJoint(int alIndex);
    int GetJointNum();
    void RemoveJoint(iPhysicsJoint *apJoint);

    virtual void SetLinearVelocity(const cVector3f &avVel) = 0;
    virtual cVector3f GetLinearVelocity() const = 0;
    virtual void SetAngularVelocity(const cVector3f &avVel) = 0;
    virtual cVector3f GetAngularVelocity() const = 0;
    virtual void SetLinearDamping(float afDamping) = 0;
    virtual float GetLinearDamping() const = 0;
    virtual void SetAngularDamping(float afDamping) = 0;
    virtual float GetAngularDamping() const = 0;
    virtual void SetMaxLinearSpeed(float afSpeed) = 0;
    virtual float GetMaxLinearSpeed() const = 0;
    virtual void SetMaxAngularSpeed(float afDamping) = 0;
    virtual float GetMaxAngularSpeed() const = 0;
    virtual cMatrixf GetInertiaMatrix() = 0;

    cVector3f GetVelocityAtPosition(cVector3f avPos);

    virtual void SetMass(float afMass) = 0;
    virtual float GetMass() const = 0;
    virtual void SetMassCentre(const cVector3f &avCentre) = 0;
    virtual cVector3f GetMassCentre() const = 0;

    virtual void AddForce(const cVector3f &avForce) = 0;
    virtual void AddForceAtPosition(const cVector3f &avForce, const cVector3f &avPos) = 0;
    virtual void AddTorque(const cVector3f &avTorque) = 0;
    virtual void AddImpulse(const cVector3f &avImpulse) = 0;
    virtual void AddImpulseAtPosition(const cVector3f &avImpulse, const cVector3f &avPos) = 0;

    virtual void SetEnabled(bool abEnabled) = 0;
    virtual bool GetEnabled() const = 0;
    virtual void SetAutoDisable(bool abEnabled) = 0;
    virtual bool GetAutoDisable() const = 0;
#if 0
    virtual void SetAutoDisableLinearThreshold(float afThresold) = 0;
    virtual float GetAutoDisableLinearThreshold() const = 0;
    virtual void SetAutoDisableAngularThreshold(float afThresold) = 0;
    virtual float GetAutoDisableAngularThreshold() const = 0;
    virtual void SetAutoDisableNumSteps(int alNum) = 0;
    virtual int GetAutoDisableNumSteps() const = 0;
#endif
    virtual void SetContinuousCollision(bool abOn) = 0;
    virtual bool GetContinuousCollision() = 0;

    virtual void SetGravity(bool abEnabled) = 0;
    virtual bool GetGravity() const = 0;

    virtual void RenderDebugGeometry(iLowLevelGraphics *apLowLevel, const cColor &aColor) = 0;

    void UpdateBeforeSimulate(float afTimeStep);
    void UpdateAfterSimulate(float afTimeStep);

    cBoundingVolume *GetBV() { return &mBoundingVolume; }

    void SetBlocksSound(bool abX) { mbBlocksSound = abX; }
    bool GetBlocksSound() { return mbBlocksSound; }

    void SetBlocksLight(bool abX) { mbBlocksLight = abX; }
    bool GetBlocksLight() { return mbBlocksLight; }

    void SetScrapeSoundEntity(cSoundEntity *apEntity) { mpScrapeSoundEntity = apEntity; }
    cSoundEntity *GetScrapeSoundEntity() { return mpScrapeSoundEntity; }
    void SetScrapeBody(iPhysicsBody *apBody) { mpScrapeBody = apBody; }
    iPhysicsBody *GetScrapeBody() { return mpScrapeBody; }
    const cMatrixf &GetPreveScrapeMatrix() { return m_mtxPrevScrapeMatrix; }
    void SetPreveScrapeMatrix(const cMatrixf &a_mtxMtx) { m_mtxPrevScrapeMatrix = a_mtxMtx; }

    void SetRollSoundEntity(cSoundEntity *apEntity) { mpRollSoundEntity = apEntity; }
    cSoundEntity *GetRollSoundEntity() { return mpRollSoundEntity; }

    void SetHasImpact(bool abX) { mbHasImpact = abX; }
    bool HasImpact() { return mbHasImpact; }
    void SetHasSlide(bool abX) { mbHasSlide = abX; }
    bool HasSlide() { return mbHasSlide; }

    bool HasCollision() { return mbHasCollision; }

    void SetUserData(void *apUserData) { mpUserData = apUserData; }
    void *GetUserData() { return mpUserData; }

    void AddBodyCallback(iPhysicsBodyCallback *apCallback);
    void RemoveBodyCallback(iPhysicsBodyCallback *apCallback);

    bool OnBeginCollision(iPhysicsBody *apBody);
    void OnCollide(iPhysicsBody *apBody, cPhysicsContactData *apContactData);

    void SetCollide(bool abX) { mbCollide = abX; }
    bool GetCollide() { return mbCollide; }

    void SetIsCharacter(bool abX) { mbIsCharacter = abX; }
    bool IsCharacter() { return mbIsCharacter; }

    void SetCollideCharacter(bool abX) { mbCollideCharacter = abX; }
    bool GetCollideCharacter() { return mbCollideCharacter; }

    void SetCharacterBody(iCharacterBody *apCharBody) { mpCharacterBody = apCharBody; }
    iCharacterBody *GetCharacterBody() { return mpCharacterBody; }

    void SetIsRagDoll(bool abX) { mbIsRagDoll = abX; }
    bool IsRagDoll() { return mbIsRagDoll; }

    void SetCollideRagDoll(bool abX) { mbCollideRagDoll = abX; }
    bool GetCollideRagDoll() { return mbCollideRagDoll; }

    void SetVolatile(bool abX) { mbVolatile = abX; }
    bool IsVolatile() { return mbVolatile; }

    void SetPushedByCharacterGravity(bool abX) { mbPushedByCharacterGravity = abX; }
    bool GetPushedByCharacterGravity() { return mbPushedByCharacterGravity; }

    void SetBuoyancyId(int alX) { mlBuoyancyId = alX; }
    void SetBuoyancyActive(bool abX) { mBuoyancy.mbActive = abX; }
    void SetBuoyancyDensity(float afX) { mBuoyancy.mfDensity = afX; }
    void SetBuoyancyLinearViscosity(float afX) { mBuoyancy.mfLinearViscosity = afX; }
    void SetBuoyancyAngularViscosity(float afX) { mBuoyancy.mfAngularViscosity = afX; }
    void SetBuoyancySurface(const cPlanef &aP) { mBuoyancy.mSurface = aP; }

    int GetBuoyancyId() { return mlBuoyancyId; }
    bool GetBuoyancyActive() { return mBuoyancy.mbActive; }
    float GetBuoyancyDensity() { return mBuoyancy.mfDensity; }
    float GetBuoyancyLinearViscosity() { return mBuoyancy.mfLinearViscosity; }
    float GetBuoyancyAngularViscosity() { return mBuoyancy.mfAngularViscosity; }
    cPlanef SetBuoyancySurface() { return mBuoyancy.mSurface; }

    void SetCanAttachCharacter(bool abX) { mbCanAttachCharacter = abX; }
    bool GetCanAttachCharacter() { return mbCanAttachCharacter; }
    void AddAttachedCharacter(iCharacterBody *apChar);
    void RemoveAttachedCharacter(iCharacterBody *apChar);

    iPhysicsWorld *GetWorld() { return mpWorld; }

    void DisableAfterSimulation() { mbDisableAfterSimulation = true; }

    // Entity implementation
    tString GetEntityType() { return "Body"; }

    // SaveObject implementation
    virtual iSaveData *CreateSaveData();
    virtual void SaveToSaveData(iSaveData *apSaveData);
    virtual void LoadFromSaveData(iSaveData *apSaveData);
    virtual void SaveDataSetup(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame);

    virtual void DeleteLowLevel() = 0;

protected:
    void CreateSaveCollideShapes(cContainerList<cSaveData_iCollideShape> *apShapeList);

    iPhysicsWorld *mpWorld;
    iCollideShape *mpShape;
    iPhysicsMaterial *mpMaterial;
    cNode3D *mpNode;

    iCharacterBody *mpCharacterBody;

    Common::Array<iPhysicsJoint *> mvJoints;

    Common::List<iCharacterBody *> mlstAttachedCharacters;

    iPhysicsBody *mpScrapeBody;
    cSoundEntity *mpScrapeSoundEntity;
    cSoundEntity *mpRollSoundEntity;
    cMatrixf m_mtxPrevScrapeMatrix;
    bool mbHasImpact;
    bool mbHasSlide;
    int mlSlideCount;
    int mlImpactCount;

    bool mbPushedByCharacterGravity;

    bool mbBlocksSound;
    bool mbBlocksLight;
    bool mbIsCharacter;
    bool mbCollideCharacter;
    bool mbIsRagDoll;
    bool mbCollideRagDoll;
    bool mbVolatile;

    bool mbCanAttachCharacter;

    cPhysicsBody_Buoyancy mBuoyancy;
    int mlBuoyancyId;

    bool mbDisableAfterSimulation;

    bool mbHasCollision;

    tPhysicsBodyCallbackList mlstBodyCallbacks;

    void *mpUserData;

    bool mbCollide;
};

} // namespace hpl

#endif // HPL_PHYSICS_BODY_H