CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPhysX/plPXPhysicalController.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#ifndef plPXPhysicalController_h_inc
#define plPXPhysicalController_h_inc

#include "plAvatar/plAvCallbackAction.h"
#include "hsQuat.h"

#define PHYSX_ONLY_TRIGGER_FROM_KINEMATIC 1

class NxController;
class NxCapsuleController;
class NxActor;
class plCoordinateInterface;
class plPhysicalProxy;
class plDrawableSpans;
class hsGMaterial;
class NxCapsule;
#ifndef PLASMA_EXTERNAL_RELEASE
class plDbgCollisionInfo
{
public:
    plSceneObject *fSO;
    hsVector3 fNormal;
    hsBool fOverlap;
};
#endif // PLASMA_EXTERNAL_RELEASE

class plPXPhysicalController : public plPhysicalController
{
public:
    plPXPhysicalController(plKey ownerSO, hsScalar height, hsScalar radius);
    virtual ~plPXPhysicalController();

    virtual void Enable(bool enable);
    virtual bool IsEnabled() const { return fEnable; }

    virtual void SetLOSDB(plSimDefs::plLOSDB losDB) { fLOSDB = losDB; }
    plSimDefs::plLOSDB GetLOSDB() const { return fLOSDB; }

    virtual void SetVelocities(const hsVector3& linearVel, hsScalar angVel)
    {
        fLinearVelocity = linearVel;
        fAngularVelocity = angVel;
    }

    virtual const hsVector3& GetLinearVelocity() const { return fAchievedLinearVelocity; }
    virtual void ResetAchievedLinearVelocity() { fAchievedLinearVelocity.Set(0.f, 0.f, 0.f); }

    virtual plKey GetSubworld() const { return fWorldKey; }
    virtual void SetSubworld(plKey world);

    virtual bool IsOnGround() const { return fTimeInAir < kAirTimeThreshold || fFalseGround; }
    virtual bool IsOnFalseGround() const { return fFalseGround && !fGroundHit; }
    virtual void GroundHit() { fGroundHit = true; }
    virtual hsScalar GetAirTime() const { return fTimeInAir; }
    virtual void ResetAirTime() { fTimeInAir = 0.f; }
    virtual void AddSlidingNormal(hsVector3 vec);
    virtual hsTArray<hsVector3>* GetSlidingNormals() { return &fSlidingNormals; }

    virtual plPhysical* GetPushingPhysical() const { return fPushingPhysical; }
    virtual bool        GetFacingPushingPhysical() const { return fFacingPushingPhysical; }

    virtual const plCoordinateInterface* GetSubworldCI() const;

    virtual void GetState(hsPoint3& pos, float& zRot);
    virtual void SetState(const hsPoint3& pos, float zRot);

    plKey GetOwner() const { return fOwner; }

    // Called by the simulation mgr each frame
    static void Update(bool prestep, hsScalar delSecs);
    // Used by the LOS mgr to find the controller for an actor it hit
    static plPXPhysicalController* GetController(NxActor& actor, bool* isController);
    // test to see if there are any controllers (i.e. avatars) in this subworld
    static bool plPXPhysicalController::AnyControllersInThisWorld(plKey world);
    static int plPXPhysicalController::NumControllers();
    static int plPXPhysicalController::GetControllersInThisSubWorld(plKey world, int maxToReturn, 
        plPXPhysicalController** bufferout);
    static int plPXPhysicalController::GetNumberOfControllersInThisSubWorld(plKey world);
    // Call this if a static physical in the scene has changed (unloaded,
    // collision enabled/disabled, etc)
    static void RebuildCache();

    virtual void GetPositionSim(hsPoint3& pos) const { IGetPositionSim(pos); }

    virtual void Kinematic(bool state);
    virtual bool IsKinematic();
    virtual void GetKinematicPosition(hsPoint3& pos);

    virtual plDrawableSpans* CreateProxy(hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo);

    virtual const hsMatrix44& GetPrevSubworldW2L() { return fPrevSubworldW2L; }

    virtual void SetSeek(bool seek){fSeeking=seek;}
    virtual void GetWorldSpaceCapsule(NxCapsule& cap);
#ifndef PLASMA_EXTERNAL_RELEASE
    static hsBool fDebugDisplay;
#endif // PLASMA_EXTERNAL_RELEASE

protected:
    static const hsScalar kAirTimeThreshold;

    friend class PXControllerHitReport;
    static plPXPhysicalController* FindController(NxController* controller);

    void IApply(hsScalar delSecs);
    void ISendUpdates(hsScalar delSecs);
    void ICheckForFalseGround();
    void ISetGlobalLoc(const hsMatrix44& l2w);
    void IMatchKinematicToController();
    void IMoveKinematicToController(hsPoint3& pos);
    void ISetKinematicLoc(const hsMatrix44& l2w);
    void IGetPositionSim(hsPoint3& pos) const;

    void ICreateController();
    void IDeleteController();

    void IInformDetectors(bool entering);

    plKey fOwner;
    plKey fWorldKey;
    hsScalar fRadius, fHeight;
    NxCapsuleController* fController;

    // this is the kinematic actor for triggering things when the avatar is collision-less during behaviors
    NxActor* fKinematicActor;

    hsVector3 fLinearVelocity;
    hsScalar fAngularVelocity;

    hsVector3 fAchievedLinearVelocity;

    // The global position and rotation of the avatar last time we set it (so we
    // can detect if someone else moves him)
    hsMatrix44 fLastGlobalLoc;
    //
    hsPoint3 fLocalPosition;
    hsQuat fLocalRotation;

    hsMatrix44 fPrevSubworldW2L;

    bool fEnable;
    bool fEnableChanged;
    plSimDefs::plLOSDB fLOSDB;

    bool fKinematic;
    bool fKinematicChanged;
    bool fKinematicEnableNextUpdate;

    bool fGroundHit;
    bool fFalseGround;
    hsScalar fTimeInAir;
    hsTArray<hsVector3> fSlidingNormals;
    hsTArray<hsVector3> fPrevSlidingNormals;

#ifndef PLASMA_EXTERNAL_RELEASE
    hsTArray<plDbgCollisionInfo> fDbgCollisionInfo;
    void IDrawDebugDisplay();
#endif // PLASMA_EXTERNAL_RELEASE

    plPhysical* fPushingPhysical;
    bool fFacingPushingPhysical;

    plPhysicalProxy* fProxyGen;             // visual proxy for debugging

    bool fHitHead;
    
    bool fSeeking;
};

#endif // plPXPhysicalController_h_inc