PhysicsController.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_CONTROLLER_H
#define HPL_PHYSICS_CONTROLLER_H

#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/math/PidController.h"
#include "hpl1/engine/math/Spring.h"

#include "hpl1/engine/game/SaveGame.h"

namespace hpl {

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

enum ePhysicsControllerType {
    ePhysicsControllerType_Pid,
    ePhysicsControllerType_Spring,
    ePhysicsControllerType_LastEnum
};

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

enum ePhysicsControllerInput {
    ePhysicsControllerInput_JointAngle,
    ePhysicsControllerInput_JointDist,
    ePhysicsControllerInput_LinearSpeed,
    ePhysicsControllerInput_AngularSpeed,
    ePhysicsControllerInput_LastEnum
};

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

enum ePhysicsControllerOutput {
    ePhysicsControllerOutput_Force,
    ePhysicsControllerOutput_Torque,
    ePhysicsControllerOutput_LastEnum
};

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

enum ePhysicsControllerAxis {
    ePhysicsControllerAxis_X,
    ePhysicsControllerAxis_Y,
    ePhysicsControllerAxis_Z,
    ePhysicsControllerAxis_LastEnum
};

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

enum ePhysicsControllerEnd {
    ePhysicsControllerEnd_Null,
    ePhysicsControllerEnd_OnDest,
    ePhysicsControllerEnd_OnMin,
    ePhysicsControllerEnd_OnMax,
    ePhysicsControllerEnd_LastEnum
};

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

kSaveData_BaseClass(iPhysicsController) {
    kSaveData_ClassInit(iPhysicsController) public : tString msName;

    int mlBodyId;
    int mlJointId;

    float mfA;
    float mfB;
    float mfC;
    float mfDestValue;
    float mfMaxOutput;

    bool mbMulMassWithOutput;

    int mType;
    int mInputType;
    int mInputAxis;
    int mOutputType;
    int mOutputAxis;
    int mEndType;

    tString msNextController;

    bool mbActive;
    bool mbPaused;

    iSaveObject *CreateSaveObject(cSaveObjectHandler * apSaveObjectHandler, cGame * apGame) { return NULL; }
    int GetSaveCreatePrio() { return 0; }
};

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

class iPhysicsWorld;
class iPhysicsJoint;
class iPhysicsBody;

class iPhysicsController : public iSaveObject {
    typedef iSaveObject super;

public:
    iPhysicsController(const tString &asName, iPhysicsWorld *apWorld);
    virtual ~iPhysicsController();

    void Update(float afTimeStep);

    const tString &GetName() { return msName; }

    void SetJoint(iPhysicsJoint *apJoint) { mpJoint = apJoint; }
    iPhysicsJoint *GetJoint() { return mpJoint; }
    void SetBody(iPhysicsBody *apBody) { mpBody = apBody; }
    iPhysicsBody *GetBody() { return mpBody; }

    bool IsActive() { return mbActive; }
    void SetActive(bool abX);

    /*
     * p in Pid and k in springs
     */
    void SetA(float afA) { mfA = afA; }
    /*
     * i in Pid and b in springs
     */
    void SetB(float afB) { mfB = afB; }
    /*
     * d in Pid and not used in springs
     */
    void SetC(float afC) { mfC = afC; }

    void SetPidIntegralSize(int alSize);

    void SetType(ePhysicsControllerType aType) { mType = aType; }

    void SetDestValue(float afX) { mfDestValue = afX; }
    float GetDestValue() { return mfDestValue; }

    void SetMaxOutput(float afX) { mfMaxOutput = afX; }

    void SetInputType(ePhysicsControllerInput aInput, ePhysicsControllerAxis aAxis) {
        mInputType = aInput;
        mInputAxis = aAxis;
    }

    void SetOutputType(ePhysicsControllerOutput aOutput, ePhysicsControllerAxis aAxis) {
        mOutputType = aOutput;
        mOutputAxis = aAxis;
    }
    void SetMulMassWithOutput(bool abX) { mbMulMassWithOutput = abX; }

    void SetEndType(ePhysicsControllerEnd aEnd) { mEndType = aEnd; }
    ePhysicsControllerEnd GetEndType() { return mEndType; }

    void SetNextController(const tString &asName) { msNextController = asName; }
    const tString &GetNextController() { return msNextController; }

    void SetLogInfo(bool abX) { mbLogInfo = abX; }

    void SetPaused(bool abX) { mbPaused = abX; }

    static bool mbUseInputMatrixFix;

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

protected:
    cVector3f GetInputValue(ePhysicsControllerInput aInput);
    float GetOutputValue(float afError, float afInput, float afTimeStep);
    void AddOutputValue(ePhysicsControllerOutput aOutput, ePhysicsControllerAxis aAxis,
                        float afVal);
    float GetAxisValue(ePhysicsControllerAxis aAxis, const cVector3f &avVec);

    iPhysicsWorld *mpWorld;
    tString msName;

    iPhysicsBody *mpBody;
    iPhysicsJoint *mpJoint;

    float mfA, mfB, mfC;

    float mfDestValue;
    float mfMaxOutput;

    bool mbMulMassWithOutput;

    ePhysicsControllerType mType;

    ePhysicsControllerInput mInputType;
    ePhysicsControllerAxis mInputAxis;

    ePhysicsControllerOutput mOutputType;
    ePhysicsControllerAxis mOutputAxis;

    ePhysicsControllerEnd mEndType;

    tString msNextController;

    cPidControllerf mPidController;

    bool mbActive;
    bool mbPaused;

    bool mbLogInfo;
};

} // namespace hpl

#endif // HPL_PHYSICS_CONTROLLER_H