PhysicsJoint.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_JOINT_H
#define HPL_PHYSICS_JOINT_H
 
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/system/SystemTypes.h"
#include "common/stablemap.h"
 
#include "hpl1/engine/game/SaveGame.h"
 
#include "hpl1/engine/physics/PhysicsController.h"
 
namespace hpl {
 
class iPhysicsBody;
class iPhysicsWorld;
class cSoundEntity;
class iPhysicsJoint;
class iPhysicsController;
 
typedef Common::StableMap<tString, iPhysicsController *> tPhysicsControllerMap;
typedef tPhysicsControllerMap::iterator tPhysicsControllerMapIt;
 
typedef cSTLMapIterator<iPhysicsController *, tPhysicsControllerMap, tPhysicsControllerMapIt> cPhysicsControllerIterator;
 
//-----------------------------------
 
enum ePhysicsJointType {
    ePhysicsJointType_Ball,
    ePhysicsJointType_Hinge,
    ePhysicsJointType_Slider,
    ePhysicsJointType_Screw,
    ePhysicsJointType_LastEnum
};
 
//-----------------------------------
 
enum ePhysicsJointSpeed {
    ePhysicsJointSpeed_Linear,
    ePhysicsJointSpeed_Angular,
    ePhysicsJointSpeed_LastEnum
};
 
//-----------------------------------
 
class cJointLimitEffect : public iSerializable {
    kSerializableClassInit(cJointLimitEffect) public : tString msSound;
    float mfMinSpeed;
    float mfMaxSpeed;
};
 
//-----------------------------------
 
class iPhysicsJointCallback {
public:
    virtual ~iPhysicsJointCallback() {}
 
    virtual void OnMinLimit(iPhysicsJoint *apJoint) = 0;
    virtual void OnMaxLimit(iPhysicsJoint *apJoint) = 0;
 
    // Ugly trick to support joint script callback.
    virtual bool IsScript() { return false; }
};
 
//-----------------------------------
 
kSaveData_BaseClass(iPhysicsJoint) {
    kSaveData_ClassInit(iPhysicsJoint) public : tString msName;
 
    int mlParentBodyId;
    int mlChildBodyId;
 
    cMatrixf m_mtxParentBodySetup;
    cMatrixf m_mtxChildBodySetup;
 
    cVector3f mvPinDir;
    cVector3f mvStartPivotPoint;
 
    cContainerList<cSaveData_iPhysicsController> mlstControllers;
 
    cJointLimitEffect mMaxLimit;
    cJointLimitEffect mMinLimit;
 
    tString msMoveSound;
 
    float mfMinMoveSpeed;
    float mfMinMoveFreq;
    float mfMinMoveFreqSpeed;
    float mfMinMoveVolume;
    float mfMaxMoveFreq;
    float mfMaxMoveFreqSpeed;
    float mfMaxMoveVolume;
    float mfMiddleMoveSpeed;
    float mfMiddleMoveVolume;
    int mMoveSpeedType;
 
    bool mbBreakable;
    float mfBreakForce;
    tString msBreakSound;
    bool mbBroken;
 
    tString msCallbackMaxFunc;
    tString msCallbackMinFunc;
    bool mbAutoDeleteCallback;
};
 
//-----------------------------------
 
class iPhysicsJoint : public iSaveObject {
    typedef iSaveObject super;
 
public:
    iPhysicsJoint(const tString &asName, iPhysicsBody *apParentBody, iPhysicsBody *apChildBody,
                  iPhysicsWorld *apWorld, const cVector3f &avPivotPoint);
    virtual ~iPhysicsJoint();
 
    const tString &GetName() { return msName; }
 
    iPhysicsBody *GetParentBody() { return mpParentBody; }
    iPhysicsBody *GetChildBody() { return mpChildBody; }
 
    void RemoveBody(iPhysicsBody *apBody);
 
    cVector3f GetPivotPoint() { return mvPivotPoint; }
    cVector3f GetPinDir() { return mvPinDir; }
 
    virtual ePhysicsJointType GetType() = 0;
 
    virtual void SetCollideBodies(bool abX) = 0;
    virtual bool GetCollideBodies() = 0;
 
    virtual void SetStiffness(float afX) = 0;
    virtual float GetStiffness() = 0;
 
    virtual cVector3f GetVelocity() = 0;
    virtual cVector3f GetAngularVelocity() = 0;
    virtual cVector3f GetForce() = 0;
 
    virtual float GetDistance() = 0;
    virtual float GetAngle() = 0;
 
    cJointLimitEffect *GetMaxLimit() { return &mMaxLimit; }
    cJointLimitEffect *GetMinLimit() { return &mMinLimit; }
 
    void SetMoveSound(tString &asName) { msMoveSound = asName; }
 
    void SetMoveSpeedType(ePhysicsJointSpeed aType) { mMoveSpeedType = aType; }
    void SetMinMoveSpeed(float afX) { mfMinMoveSpeed = afX; }
    void SetMinMoveFreq(float afX) { mfMinMoveFreq = afX; }
    void SetMinMoveFreqSpeed(float afX) { mfMinMoveFreqSpeed = afX; }
    void SetMinMoveVolume(float afX) { mfMinMoveVolume = afX; }
    void SetMaxMoveFreq(float afX) { mfMaxMoveFreq = afX; }
    void SetMaxMoveVolume(float afX) { mfMaxMoveVolume = afX; }
    void SetMaxMoveFreqSpeed(float afX) { mfMaxMoveFreqSpeed = afX; }
    void SetMiddleMoveSpeed(float afX) { mfMiddleMoveSpeed = afX; }
    void SetMiddleMoveVolume(float afX) { mfMiddleMoveVolume = afX; }
 
    void SetCallback(iPhysicsJointCallback *apCallback, bool abAutoDelete) {
        mpCallback = apCallback;
        mbAutoDeleteCallback = abAutoDelete;
    }
 
    iPhysicsJointCallback *GetCallback() { return mpCallback; }
 
    bool CheckBreakage();
 
    void SetBreakable(bool abX) { mbBreakable = abX; }
    bool IsBreakable() { return mbBreakable; }
    void SetBreakForce(float afForce) { mfBreakForce = afForce; }
    float GetBreakForce() { return mfBreakForce; }
    void SetBreakSound(const tString &asSound) { msBreakSound = asSound; }
 
    void SetLimitAutoSleep(bool abX) { mbLimitAutoSleep = abX; }
    void SetLimitAutoSleepDist(float afX) { mfLimitAutoSleepDist = afX; }
    void SetLimitAutoSleepNumSteps(int alX) { mlLimitAutoSleepNumSteps = alX; }
 
    bool GetLimitAutoSleep() { return mbLimitAutoSleep; }
    float GetLimitAutoSleepDist() { return mfLimitAutoSleepDist; }
    int GetLimitAutoSleepNumSteps() { return mlLimitAutoSleepNumSteps; }
 
    void SetStickyMinDistance(float afX) { mfStickyMinDistance = afX; }
    void SetStickyMaxDistance(float afX) { mfStickyMaxDistance = afX; }
    float GetStickyMinDistance() { return mfStickyMinDistance; }
    float GetStickyMaxDistance() { return mfStickyMaxDistance; }
 
    void Break();
 
    bool IsBroken() { return mbBroken; }
 
    void SetUserData(void *apUserData) { mpUserData = apUserData; }
 
    void AddController(iPhysicsController *apController);
    iPhysicsController *GetController(const tString &asName);
    bool ChangeController(const tString &asName);
    cPhysicsControllerIterator GetControllerIterator();
 
    void SetAllControllersPaused(bool abX);
 
    void OnPhysicsUpdate();
 
    void SetSound(cSoundEntity *apSound) { mpSound = apSound; }
    cSoundEntity *GetSound() { return mpSound; }
 
    // SaveObject implementation
    virtual iSaveData *CreateSaveData();
    virtual void SaveToSaveData(iSaveData *apSaveData);
    virtual void LoadFromSaveData(iSaveData *apSaveData);
    virtual void SaveDataSetup(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame);
 
protected:
    tString msName;
 
    iPhysicsBody *mpParentBody;
    iPhysicsBody *mpChildBody;
    iPhysicsWorld *mpWorld;
 
    cMatrixf m_mtxParentBodySetup;
    cMatrixf m_mtxChildBodySetup;
 
    cVector3f mvPinDir;
    cVector3f mvPivotPoint;
    cVector3f mvStartPivotPoint;
 
    cVector3f mvLocalPivot;
 
    float mfStickyMinDistance;
    float mfStickyMaxDistance;
 
    tPhysicsControllerMap m_mapControllers;
 
    cJointLimitEffect mMaxLimit;
    cJointLimitEffect mMinLimit;
 
    int mlSpeedCount;
 
    cMatrixf m_mtxPrevChild;
    cMatrixf m_mtxPrevParent;
 
    tString msMoveSound;
 
    float mfMinMoveSpeed;
    float mfMinMoveFreq;
    float mfMinMoveFreqSpeed;
    float mfMinMoveVolume;
    float mfMaxMoveFreq;
    float mfMaxMoveFreqSpeed;
    float mfMaxMoveVolume;
    float mfMiddleMoveSpeed;
    float mfMiddleMoveVolume;
    ePhysicsJointSpeed mMoveSpeedType;
 
    bool mbBreakable;
    float mfBreakForce;
    tString msBreakSound;
    bool mbBroken;
 
    bool mbLimitAutoSleep;
    float mfLimitAutoSleepDist;
    int mlLimitAutoSleepNumSteps;
 
    cSoundEntity *mpSound;
    bool mbHasCollided;
 
    iPhysicsJointCallback *mpCallback;
    bool mbAutoDeleteCallback;
 
    int mlLimitStepCount;
 
    void *mpUserData;
 
    static void CheckLimitAutoSleep(iPhysicsJoint *apJoint, const float afMin, const float afMax,
                                    const float afDist);
 
    void OnMaxLimit();
    void OnMinLimit();
    void OnNoLimit();
 
    void CalcSoundFreq(float afSpeed, float *apFreq, float *apVol);
 
    void LimitEffect(cJointLimitEffect *pEffect);
};
 
} // namespace hpl
 
#endif // HPL_PHYSICS_JOINT_H