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