Branan Purvine-Riley
12 years ago
43 changed files with 1909 additions and 5321 deletions
@ -1,171 +0,0 @@ |
|||||||
/*==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/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
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==*/ |
|
||||||
#if 0 |
|
||||||
// havok first
|
|
||||||
#include <hkdynamics/entity/rigidbody.h> |
|
||||||
#include <hkdynamics/world/subspace.h> |
|
||||||
|
|
||||||
#include "plAntiGravAction.h" |
|
||||||
|
|
||||||
#include "pnSceneObject/plSceneObject.h" |
|
||||||
#include "plHavok1/plHKPhysical.h" |
|
||||||
#include "plAvatar/plSwimRegion.h" |
|
||||||
#include "hsTimer.h" |
|
||||||
|
|
||||||
// This is meant to be a specific physicsAction for the swim behavior
|
|
||||||
plAntiGravAction::plAntiGravAction(plHKPhysical *physical, plAGApplicator *rootApp) :
|
|
||||||
plAnimatedCallbackAction(physical, rootApp), |
|
||||||
fOnGround(false), |
|
||||||
fBuoyancy(1.f), |
|
||||||
fSurfaceHeight(0.f), |
|
||||||
fCurrentRegion(nil), |
|
||||||
fHadContacts(false) |
|
||||||
{ |
|
||||||
} |
|
||||||
|
|
||||||
plSimDefs::ActionType plAntiGravAction::GetType() |
|
||||||
{ |
|
||||||
return plSimDefs::kAntiGravAction; |
|
||||||
} |
|
||||||
|
|
||||||
void plAntiGravAction::apply(Havok::Subspace &space, Havok::hkTime time) |
|
||||||
{ |
|
||||||
double elapsed = time.asDouble() - getRefresh().asDouble(); |
|
||||||
setRefresh(time); |
|
||||||
|
|
||||||
IAdjustBuoyancy();
|
|
||||||
Havok::RigidBody *body = fPhysical->GetBody(); |
|
||||||
float mass = body->getMass(); |
|
||||||
Havok::Vector3 gravity = space.getGravity(); |
|
||||||
Havok::Vector3 force = -gravity * (mass * fBuoyancy); |
|
||||||
body->applyForce(force); |
|
||||||
|
|
||||||
hsVector3 vel; |
|
||||||
fPhysical->GetLinearVelocitySim(vel); |
|
||||||
fAnimPosVel.fZ = vel.fZ; |
|
||||||
|
|
||||||
hsVector3 linCurrent(0.f, 0.f, 0.f); |
|
||||||
float angCurrent = 0.f; |
|
||||||
if (fCurrentRegion != nil) |
|
||||||
fCurrentRegion->GetCurrent(fPhysical, linCurrent, angCurrent, (float)elapsed); |
|
||||||
|
|
||||||
int numContacts = fPhysical->GetNumContacts(); |
|
||||||
fHadContacts = (numContacts > 0); |
|
||||||
|
|
||||||
const Havok::Vector3 straightUp(0.0f, 0.0f, 1.0f);
|
|
||||||
fOnGround = false; |
|
||||||
int i; |
|
||||||
for (i = 0; i < numContacts; i++) |
|
||||||
{ |
|
||||||
const Havok::ContactPoint *contact = fPhysical->GetContactPoint(i);
|
|
||||||
float dotUp = straightUp.dot(contact->m_normal); |
|
||||||
if (dotUp > .5) |
|
||||||
{ |
|
||||||
fOnGround = true; |
|
||||||
break; |
|
||||||
} |
|
||||||
}
|
|
||||||
|
|
||||||
fPhysical->SetLinearVelocitySim(fAnimPosVel + linCurrent); |
|
||||||
fPhysical->SetAngularVelocitySim(hsVector3(0.f, 0.f, fAnimAngVel + fTurnStr + angCurrent));
|
|
||||||
} |
|
||||||
|
|
||||||
void plAntiGravAction::SetSurface(plSwimRegionInterface *region, float surfaceHeight) |
|
||||||
{ |
|
||||||
fCurrentRegion = region; |
|
||||||
if (region != nil) |
|
||||||
fSurfaceHeight = surfaceHeight; |
|
||||||
} |
|
||||||
|
|
||||||
void plAntiGravAction::IAdjustBuoyancy() |
|
||||||
{ |
|
||||||
// "surface depth" refers to the depth our handle object should be below
|
|
||||||
// the surface for the avatar to be "at the surface"
|
|
||||||
static const float surfaceDepth = 4.0f; |
|
||||||
// 1.0 = neutral buoyancy
|
|
||||||
// 0 = no buoyancy (normal gravity)
|
|
||||||
// 2.0 = opposite of gravity, floating upwards
|
|
||||||
static const float buoyancyAtSurface = 1.0f; |
|
||||||
|
|
||||||
if (fCurrentRegion == nil) |
|
||||||
{ |
|
||||||
fBuoyancy = 0.f; |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
hsMatrix44 l2w, w2l; |
|
||||||
fPhysical->GetTransform(l2w, w2l); |
|
||||||
float depth = fSurfaceHeight - surfaceDepth - l2w.GetTranslate().fZ;
|
|
||||||
if (depth < -1) |
|
||||||
fBuoyancy = 0.f; // Same as being above ground. Plain old gravity.
|
|
||||||
else if (depth < 0) |
|
||||||
fBuoyancy = 1 + depth; |
|
||||||
else
|
|
||||||
{ |
|
||||||
hsVector3 vel; |
|
||||||
fPhysical->GetLinearVelocitySim(vel); |
|
||||||
if (vel.fZ > 0) |
|
||||||
{ |
|
||||||
if (vel.fZ > fCurrentRegion->fMaxUpwardVel) |
|
||||||
{ |
|
||||||
vel.fZ = fCurrentRegion->fMaxUpwardVel; |
|
||||||
fPhysical->SetLinearVelocitySim(vel); |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
if (depth > 1) |
|
||||||
fBuoyancy = fCurrentRegion->fUpBuoyancy; |
|
||||||
else |
|
||||||
fBuoyancy = (fCurrentRegion->fUpBuoyancy - 1) * depth + 1; |
|
||||||
} |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
if (depth > 1) |
|
||||||
fBuoyancy = fCurrentRegion->fDownBuoyancy; |
|
||||||
else |
|
||||||
fBuoyancy = (fCurrentRegion->fDownBuoyancy - 1) * depth + 1; |
|
||||||
} |
|
||||||
}
|
|
||||||
} |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -1,79 +0,0 @@ |
|||||||
/*==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/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
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==*/ |
|
||||||
#if 0//ndef PL_ANTI_GRAV_ACTION_H
|
|
||||||
#define PL_ANTI_GRAV_ACTION_H |
|
||||||
|
|
||||||
#include "plAvCallbackAction.h" |
|
||||||
|
|
||||||
class plSwimRegionInterface; |
|
||||||
|
|
||||||
class plAntiGravAction : public plAnimatedCallbackAction |
|
||||||
{ |
|
||||||
public: |
|
||||||
plAntiGravAction(plHKPhysical *physical, plAGApplicator *rootApp); |
|
||||||
|
|
||||||
/** Return the type of the action as defined in the enum plSimDefs::ActionType.
|
|
||||||
Used to retrieve actions by entity/type indexing, and to |
|
||||||
reuse actions that can be shared between entities. */ |
|
||||||
virtual plSimDefs::ActionType GetType(); |
|
||||||
|
|
||||||
/** Called by Havok at substep frequency. */ |
|
||||||
void apply(Havok::Subspace &s, Havok::hkTime time); |
|
||||||
|
|
||||||
void SetSurface(plSwimRegionInterface *region, float surfaceHeight); |
|
||||||
float GetBuoyancy() { return fBuoyancy; } |
|
||||||
bool IsOnGround() { return fOnGround; } |
|
||||||
bool HadContacts() { return fHadContacts; } |
|
||||||
|
|
||||||
protected: |
|
||||||
void IAdjustBuoyancy(); |
|
||||||
|
|
||||||
bool fOnGround; |
|
||||||
bool fHadContacts; |
|
||||||
float fBuoyancy; |
|
||||||
float fSurfaceHeight; |
|
||||||
plSwimRegionInterface *fCurrentRegion; |
|
||||||
}; |
|
||||||
|
|
||||||
#endif |
|
||||||
|
|
||||||
|
|
||||||
@ -1,579 +0,0 @@ |
|||||||
/*==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/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
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==*/ |
|
||||||
#include "plAvCallbackAction.h" |
|
||||||
#include "plMessage/plLOSHitMsg.h" |
|
||||||
|
|
||||||
#include "plArmatureMod.h" // for LOS enum type |
|
||||||
#include "plMatrixChannel.h" |
|
||||||
#include "hsTimer.h" |
|
||||||
#include "plPhysicalControllerCore.h" |
|
||||||
|
|
||||||
// Generic geom utils.
|
|
||||||
static bool LinearVelocity(hsVector3 &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat); |
|
||||||
static void AngularVelocity(float &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat); |
|
||||||
static float AngleRad2d (float x1, float y1, float x3, float y3); |
|
||||||
inline hsVector3 GetYAxis(hsMatrix44 &mat) |
|
||||||
{ |
|
||||||
return hsVector3(mat.fMap[1][0], mat.fMap[1][1], mat.fMap[1][2]); |
|
||||||
} |
|
||||||
|
|
||||||
plAnimatedController::plAnimatedController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller) |
|
||||||
: fRootObject(rootObject) |
|
||||||
, fRootApp(rootApp) |
|
||||||
, fController(controller) |
|
||||||
, fTurnStr(0.f) |
|
||||||
, fAnimAngVel(0.f) |
|
||||||
, fAnimPosVel(0.f, 0.f, 0.f) |
|
||||||
{ |
|
||||||
}
|
|
||||||
|
|
||||||
void plAnimatedController::RecalcVelocity(double timeNow, double timePrev, bool useAnim /* = true */) |
|
||||||
{ |
|
||||||
if (useAnim) |
|
||||||
{ |
|
||||||
// while you may think it would be correct to cache this,
|
|
||||||
// what we're actually asking is "what would the animation's
|
|
||||||
// position be at the previous time given its *current*
|
|
||||||
// parameters (particularly blends)"
|
|
||||||
hsMatrix44 prevMat = ((plMatrixChannel *)fRootApp->GetChannel())->Value(timePrev, true);
|
|
||||||
hsMatrix44 curMat = ((plMatrixChannel *)fRootApp->GetChannel())->Value(timeNow, true); |
|
||||||
|
|
||||||
// If we get a valid linear velocity (ie, we didn't wrap around in the anim),
|
|
||||||
// use it. Otherwise just reuse the previous frames velocity.
|
|
||||||
hsVector3 linearVel; |
|
||||||
if (LinearVelocity(linearVel, (float)(timeNow - timePrev), prevMat, curMat)) |
|
||||||
fAnimPosVel = linearVel; |
|
||||||
|
|
||||||
// Automatically sets fAnimAngVel
|
|
||||||
AngularVelocity(fAnimAngVel, (float)(timeNow - timePrev), prevMat, curMat); |
|
||||||
} |
|
||||||
else |
|
||||||
{ |
|
||||||
fAnimPosVel.Set(0.f, 0.f, 0.f); |
|
||||||
fAnimAngVel = 0.f; |
|
||||||
} |
|
||||||
|
|
||||||
if (fController) |
|
||||||
fController->SetVelocities(fAnimPosVel, fAnimAngVel + fTurnStr); |
|
||||||
} |
|
||||||
|
|
||||||
///////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
const float plWalkingController::kControlledFlightThreshold = 1.f; // seconds
|
|
||||||
|
|
||||||
plWalkingController::plWalkingController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller) |
|
||||||
: plAnimatedController(rootObject, rootApp, controller) |
|
||||||
, fHitGroundInThisAge(false) |
|
||||||
, fWaitingForGround(false) |
|
||||||
, fControlledFlightTime(0) |
|
||||||
, fControlledFlight(0) |
|
||||||
, fImpactTime(0.f) |
|
||||||
, fImpactVelocity(0.f, 0.f, 0.f) |
|
||||||
, fClearImpact(false) |
|
||||||
, fGroundLastFrame(false) |
|
||||||
{ |
|
||||||
if (fController) |
|
||||||
{ |
|
||||||
fWalkingStrategy= new plWalkingStrategy(fController); |
|
||||||
fController->SetMovementSimulationInterface(fWalkingStrategy); |
|
||||||
} |
|
||||||
else |
|
||||||
fWalkingStrategy = nil; |
|
||||||
} |
|
||||||
|
|
||||||
void plWalkingController::RecalcVelocity(double timeNow, double timePrev, bool useAnim) |
|
||||||
{ |
|
||||||
if (!fHitGroundInThisAge && fController && fController->IsEnabled() && fWalkingStrategy->IsOnGround()) |
|
||||||
fHitGroundInThisAge = true; // if we're not pinned and we're not in an age yet, we are now.
|
|
||||||
|
|
||||||
if (fClearImpact) |
|
||||||
{ |
|
||||||
fImpactTime = 0.f; |
|
||||||
fImpactVelocity.Set(0.f, 0.f, 0.f); |
|
||||||
} |
|
||||||
|
|
||||||
if (fController && !fWalkingStrategy->IsOnGround()) |
|
||||||
{ |
|
||||||
// PhysX Hack: AchievedLinearVelocity is a Cyanic fix for superjumps. LinearVelocity is
|
|
||||||
// always (0,0,0) outside of the controller update proc
|
|
||||||
fImpactTime = fWalkingStrategy->GetAirTime(); |
|
||||||
fImpactVelocity = fController->GetAchievedLinearVelocity(); |
|
||||||
// convert orientation from subworld to avatar-local coordinates
|
|
||||||
fImpactVelocity = (hsVector3)fController->GetLocalRotation().Rotate(&fImpactVelocity); |
|
||||||
fClearImpact = false; |
|
||||||
} |
|
||||||
else |
|
||||||
fClearImpact = true; |
|
||||||
|
|
||||||
if (IsControlledFlight()) |
|
||||||
{ |
|
||||||
if (fWalkingStrategy && fWalkingStrategy->IsOnGround()) |
|
||||||
fControlledFlightTime = fWalkingStrategy->GetAirTime(); |
|
||||||
if(fGroundLastFrame&&(fWalkingStrategy && !fWalkingStrategy->IsOnGround())) |
|
||||||
{ |
|
||||||
//we have started to leave the ground tell the movement strategy in case it cares
|
|
||||||
fWalkingStrategy->StartJump(); |
|
||||||
} |
|
||||||
if (fControlledFlightTime > kControlledFlightThreshold) |
|
||||||
EnableControlledFlight(false); |
|
||||||
} |
|
||||||
if (fWalkingStrategy) |
|
||||||
fGroundLastFrame = fWalkingStrategy->IsOnGround(); |
|
||||||
else |
|
||||||
fGroundLastFrame=false; |
|
||||||
plAnimatedController::RecalcVelocity(timeNow, timePrev, useAnim); |
|
||||||
} |
|
||||||
|
|
||||||
void plWalkingController::Reset(bool newAge) |
|
||||||
{ |
|
||||||
|
|
||||||
ActivateController(); |
|
||||||
if (newAge) |
|
||||||
{ |
|
||||||
if (fWalkingStrategy) |
|
||||||
fWalkingStrategy->ResetAirTime(); |
|
||||||
fHitGroundInThisAge = false; |
|
||||||
} |
|
||||||
} |
|
||||||
void plWalkingController::ActivateController() |
|
||||||
{ |
|
||||||
if (fWalkingStrategy) |
|
||||||
{ |
|
||||||
fWalkingStrategy->RefreshConnectionToControllerCore(); |
|
||||||
} |
|
||||||
else |
|
||||||
{
|
|
||||||
fWalkingStrategy= new plWalkingStrategy(fController); |
|
||||||
fWalkingStrategy->RefreshConnectionToControllerCore(); |
|
||||||
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
bool plWalkingController::EnableControlledFlight(bool status) |
|
||||||
{ |
|
||||||
if (status) |
|
||||||
{ |
|
||||||
if (fControlledFlight == 0) |
|
||||||
fControlledFlightTime = 0.f; |
|
||||||
|
|
||||||
++fControlledFlight; |
|
||||||
fWaitingForGround = true; |
|
||||||
} |
|
||||||
else |
|
||||||
fControlledFlight = max(--fControlledFlight, 0); |
|
||||||
|
|
||||||
return status; |
|
||||||
} |
|
||||||
plWalkingController::~plWalkingController() |
|
||||||
{ |
|
||||||
delete fWalkingStrategy; |
|
||||||
if (fController) |
|
||||||
fController->SetMovementSimulationInterface(nil); |
|
||||||
} |
|
||||||
#if 0 |
|
||||||
void plWalkingController::Update() |
|
||||||
{ |
|
||||||
// double elapsed = time.asDouble() - getRefresh().asDouble();
|
|
||||||
// setRefresh(time);
|
|
||||||
//
|
|
||||||
// bool isPhysical = !fPhysical->GetProperty(plSimulationInterface::kPinned);
|
|
||||||
// const Havok::Vector3 straightUp(0.0f, 0.0f, 1.0f);
|
|
||||||
// bool alreadyInAge = fHitGroundInThisAge;
|
|
||||||
//
|
|
||||||
// int numContacts = fPhysical->GetNumContacts();
|
|
||||||
// bool ground = false;
|
|
||||||
// fPushingPhysical = nil;
|
|
||||||
// int i, j;
|
|
||||||
|
|
||||||
/* for(i = 0; i < numContacts; i++)
|
|
||||||
{ |
|
||||||
plHKPhysical *contactPhys = fPhysical->GetContactPhysical(i); |
|
||||||
if (!contactPhys) |
|
||||||
continue; // Physical no longer exists. Skip it.
|
|
||||||
|
|
||||||
const Havok::ContactPoint *contact = fPhysical->GetContactPoint(i); |
|
||||||
float dotUp = straightUp.dot(contact->m_normal); |
|
||||||
if (dotUp > .5) |
|
||||||
ground = true; |
|
||||||
else if (contactPhys->GetProperty(plSimulationInterface::kAvAnimPushable)) |
|
||||||
{ |
|
||||||
hsPoint3 position; |
|
||||||
hsQuat rotation; |
|
||||||
fPhysical->GetPositionAndRotationSim(&position, &rotation); |
|
||||||
|
|
||||||
hsQuat inverseRotation = rotation.Inverse(); |
|
||||||
hsVector3 normal(contact->m_normal.x, contact->m_normal.y, contact->m_normal.z); |
|
||||||
fFacingPushingPhysical = (inverseRotation.Rotate(&kAvatarForward).InnerProduct(normal) < 0 ? true : false); |
|
||||||
|
|
||||||
fPushingPhysical = contactPhys; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// We need to check for the case where the avatar hasn't collided with "ground", but is colliding
|
|
||||||
// with a few other objects so that he's not actually falling (wedged in between some slopes).
|
|
||||||
// We do this by answering the following question (in 2d top-down space): "If you sort the contact
|
|
||||||
// normals by angle, is there a large enough gap between normals?"
|
|
||||||
//
|
|
||||||
// If you think in terms of geometry, this means a collection of surfaces are all pushing on you.
|
|
||||||
// If they're pushing from all sides, you have nowhere to go, and you won't fall. There needs to be
|
|
||||||
// a gap, so that you're pushed out and have somewhere to fall. This is the same as finding a gap
|
|
||||||
// larger than 180 degrees between sorted normals.
|
|
||||||
//
|
|
||||||
// The problem is that on top of that, the avatar needs enough force to shove him out that gap (he
|
|
||||||
// has to overcome friction). I deal with that by making the threshold (360 - (180 - 60) = 240). I've
|
|
||||||
// seen up to 220 reached in actual gameplay in a situation where we'd want this to take effect.
|
|
||||||
// This is the same running into 2 walls where the angle between them is 60.
|
|
||||||
const float threshold = hsDegreesToRadians(240); |
|
||||||
if (!ground && numContacts >= 2) |
|
||||||
{ |
|
||||||
// Can probably do a special case for exactly 2 contacts. Not sure if it's worth it...
|
|
||||||
|
|
||||||
fCollisionAngles.SetCount(numContacts); |
|
||||||
for (i = 0; i < numContacts; i++) |
|
||||||
{ |
|
||||||
const Havok::ContactPoint *contact = fPhysical->GetContactPoint(i); |
|
||||||
fCollisionAngles[i] = atan2(contact->m_normal.y, contact->m_normal.x); |
|
||||||
} |
|
||||||
|
|
||||||
// numContacts is rarely larger than 6, so let's do a simple bubble sort.
|
|
||||||
for (i = 0; i < numContacts; i++) |
|
||||||
{ |
|
||||||
for (j = i + 1; j < numContacts; j++) |
|
||||||
{ |
|
||||||
if (fCollisionAngles[i] > fCollisionAngles[j]) |
|
||||||
{ |
|
||||||
float tempAngle = fCollisionAngles[i]; |
|
||||||
fCollisionAngles[i] = fCollisionAngles[j]; |
|
||||||
fCollisionAngles[j] = tempAngle; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// sorted, now we check.
|
|
||||||
for (i = 1; i < numContacts; i++) |
|
||||||
{ |
|
||||||
if (fCollisionAngles[i] - fCollisionAngles[i - 1] >= threshold) |
|
||||||
break; |
|
||||||
} |
|
||||||
|
|
||||||
if (i == numContacts) |
|
||||||
{ |
|
||||||
// We got to the end. Check the last with the first and make your decision.
|
|
||||||
if (!(fCollisionAngles[0] - fCollisionAngles[numContacts - 1] >= (threshold - 2 * M_PI))) |
|
||||||
ground = true; |
|
||||||
} |
|
||||||
} |
|
||||||
*/ |
|
||||||
|
|
||||||
bool ground = fController ? fController->GotGroundHit() : true; |
|
||||||
bool isPhysical = true; |
|
||||||
|
|
||||||
if (!fHitGroundInThisAge && isPhysical) |
|
||||||
fHitGroundInThisAge = true; // if we're not pinned and we're not in an age yet, we are now.
|
|
||||||
|
|
||||||
if (IsControlledFlight()) |
|
||||||
fControlledFlightTime += (float)elapsed; |
|
||||||
if (fControlledFlightTime > kControlledFlightThreshold && numContacts > 0) |
|
||||||
EnableControlledFlight(false); |
|
||||||
|
|
||||||
if (ground || !isPhysical) |
|
||||||
{ |
|
||||||
if (!IsControlledFlight() && !IsOnGround()) |
|
||||||
{ |
|
||||||
// The first ground contact in an age doesn't count.
|
|
||||||
// if (alreadyInAge)
|
|
||||||
// {
|
|
||||||
// hsVector3 vel;
|
|
||||||
// fPhysical->GetLinearVelocitySim(vel);
|
|
||||||
// fImpactVel = vel.fZ;
|
|
||||||
// fTimeInAirPeak = (float)(fTimeInAir + elapsed);
|
|
||||||
// }
|
|
||||||
|
|
||||||
fWaitingForGround = false;
|
|
||||||
}
|
|
||||||
fTimeInAir = 0; |
|
||||||
} |
|
||||||
else if (elapsed < plSimulationMgr::GetInstance()->GetMaxDelta()) |
|
||||||
{ |
|
||||||
// If the simultation skipped a huge chunk of time, we didn't process the
|
|
||||||
// collisions, which could trick us into thinking we've just gone a long
|
|
||||||
// time without hitting ground. So we only count the time if this wasn't
|
|
||||||
// the case.
|
|
||||||
fTimeInAir += (float)elapsed; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Tweakage so that we still fall under the right conditions.
|
|
||||||
// If we're in controlled flight, or standing still with ground solidly under us (probe hit). We only use anim velocity.
|
|
||||||
// if (!IsControlledFlight() && !(ground && fProbeHitGround && fAnimPosVel.fX == 0 && fAnimPosVel.fY == 0))
|
|
||||||
// {
|
|
||||||
// hsVector3 curV;
|
|
||||||
// fPhysical->GetLinearVelocitySim(curV);
|
|
||||||
// fAnimPosVel.fZ = curV.fZ;
|
|
||||||
//
|
|
||||||
// // Prevents us from going airborn from running up bumps/inclines.
|
|
||||||
// if (IsOnGround() && fAnimPosVel.fZ > 0.f)
|
|
||||||
// fAnimPosVel.fZ = 0.f;
|
|
||||||
//
|
|
||||||
// // Unless we're on the ground and moving, or standing still with a probe hit, we use the sim's other axes too.
|
|
||||||
// if (!(IsOnGround() && (fProbeHitGround || fAnimPosVel.fX != 0 || fAnimPosVel.fY != 0)))
|
|
||||||
// {
|
|
||||||
// fAnimPosVel.fX = curV.fX;
|
|
||||||
// fAnimPosVel.fY = curV.fY;
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
//
|
|
||||||
// fPhysical->SetLinearVelocitySim(fAnimPosVel);
|
|
||||||
// fPhysical->SetSpin(fAnimAngVel + fTurnStr, hsVector3(0.0f, 0.0f, 1.0f));
|
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
|
|
||||||
#if 0 |
|
||||||
|
|
||||||
/////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
plSimDefs::ActionType plHorizontalFreezeAction::GetType() |
|
||||||
{ |
|
||||||
return plSimDefs::kHorizontalFreeze; |
|
||||||
} |
|
||||||
|
|
||||||
void plHorizontalFreezeAction::apply(Havok::Subspace &s, Havok::hkTime time) |
|
||||||
{ |
|
||||||
double elapsed = time.asDouble() - getRefresh().asDouble(); |
|
||||||
setRefresh(time); |
|
||||||
|
|
||||||
int numContacts = fPhysical->GetNumContacts(); |
|
||||||
bool ground = false; |
|
||||||
const Havok::Vector3 straightUp(0.0f, 0.0f, 1.0f);
|
|
||||||
int i; |
|
||||||
for(i = 0; i < numContacts; i++) |
|
||||||
{ |
|
||||||
const Havok::ContactPoint *contact = fPhysical->GetContactPoint(i); |
|
||||||
float dotUp = straightUp.dot(contact->m_normal); |
|
||||||
if (dotUp > .5) |
|
||||||
ground = true; |
|
||||||
} |
|
||||||
|
|
||||||
hsVector3 vel; |
|
||||||
fPhysical->GetLinearVelocitySim(vel); |
|
||||||
vel.fX = 0.0; |
|
||||||
vel.fY = 0.0; |
|
||||||
if (ground) |
|
||||||
vel.fZ = 0; |
|
||||||
fPhysical->SetLinearVelocitySim(vel); |
|
||||||
fPhysical->ClearContacts(); |
|
||||||
} |
|
||||||
#endif |
|
||||||
plSwimmingController::plSwimmingController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller) |
|
||||||
:plAnimatedController(rootObject,rootApp,controller) |
|
||||||
{ |
|
||||||
if (controller) |
|
||||||
fSwimmingStrategy= new plSwimStrategy(controller); |
|
||||||
else |
|
||||||
fSwimmingStrategy = nil; |
|
||||||
} |
|
||||||
plSwimmingController::~plSwimmingController() |
|
||||||
{ |
|
||||||
delete fSwimmingStrategy; |
|
||||||
} |
|
||||||
|
|
||||||
plRidingAnimatedPhysicalController::plRidingAnimatedPhysicalController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller) |
|
||||||
: plWalkingController(rootObject, rootApp, controller) |
|
||||||
{ |
|
||||||
if(controller) |
|
||||||
fWalkingStrategy = new plRidingAnimatedPhysicalStrategy(controller); |
|
||||||
else |
|
||||||
fWalkingStrategy = nil; |
|
||||||
} |
|
||||||
plRidingAnimatedPhysicalController::~plRidingAnimatedPhysicalController() |
|
||||||
{ |
|
||||||
delete fWalkingStrategy; |
|
||||||
fWalkingStrategy=nil; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
//////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
Purpose: |
|
||||||
|
|
||||||
ANGLE_RAD_2D returns the angle in radians swept out between two rays in 2D. |
|
||||||
|
|
||||||
Discussion: |
|
||||||
|
|
||||||
Except for the zero angle case, it should be true that |
|
||||||
|
|
||||||
ANGLE_RAD_2D(X1,Y1,X2,Y2,X3,Y3) |
|
||||||
+ ANGLE_RAD_2D(X3,Y3,X2,Y2,X1,Y1) = 2 * PI |
|
||||||
|
|
||||||
Modified: |
|
||||||
|
|
||||||
19 April 1999 |
|
||||||
|
|
||||||
Author: |
|
||||||
|
|
||||||
John Burkardt |
|
||||||
|
|
||||||
Parameters: |
|
||||||
|
|
||||||
Input, float X1, Y1, X2, Y2, X3, Y3, define the rays |
|
||||||
( X1-X2, Y1-Y2 ) and ( X3-X2, Y3-Y2 ) which in turn define the |
|
||||||
angle, counterclockwise from ( X1-X2, Y1-Y2 ). |
|
||||||
|
|
||||||
Output, float ANGLE_RAD_2D, the angle swept out by the rays, measured |
|
||||||
in radians. 0 <= ANGLE_DEG_2D < 2 PI. If either ray has zero length, |
|
||||||
then ANGLE_RAD_2D is set to 0. |
|
||||||
*/ |
|
||||||
|
|
||||||
static float AngleRad2d ( float x1, float y1, float x3, float y3 ) |
|
||||||
{ |
|
||||||
float value; |
|
||||||
float x; |
|
||||||
float y; |
|
||||||
|
|
||||||
x = ( x1 ) * ( x3 ) + ( y1 ) * ( y3 ); |
|
||||||
y = ( x1 ) * ( y3 ) - ( y1 ) * ( x3 ); |
|
||||||
|
|
||||||
if ( x == 0.0 && y == 0.0 ) { |
|
||||||
value = 0.0; |
|
||||||
} |
|
||||||
else
|
|
||||||
{ |
|
||||||
value = atan2 ( y, x ); |
|
||||||
|
|
||||||
if ( value < 0.0 )
|
|
||||||
{ |
|
||||||
value = (float)(value + TWO_PI); |
|
||||||
} |
|
||||||
} |
|
||||||
return value; |
|
||||||
} |
|
||||||
|
|
||||||
static bool LinearVelocity(hsVector3 &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat) |
|
||||||
{ |
|
||||||
bool result = false; |
|
||||||
|
|
||||||
hsPoint3 startPos(0.0f, 0.0f, 0.0f); // default position (at start of anim)
|
|
||||||
hsPoint3 prevPos = prevMat.GetTranslate(); // position previous frame
|
|
||||||
hsPoint3 nowPos = curMat.GetTranslate(); // position current frame
|
|
||||||
|
|
||||||
hsVector3 prev2Now = (hsVector3)(nowPos - prevPos); // frame-to-frame delta
|
|
||||||
|
|
||||||
if (fabs(prev2Now.fX) < 0.0001f && fabs(prev2Now.fY) < 0.0001f && fabs(prev2Now.fZ) < 0.0001f) |
|
||||||
{ |
|
||||||
outputV.Set(0.f, 0.f, 0.f); |
|
||||||
result = true; |
|
||||||
}
|
|
||||||
else
|
|
||||||
{ |
|
||||||
hsVector3 start2Now = (hsVector3)(nowPos - startPos); // start-to-frame delta
|
|
||||||
|
|
||||||
float prev2NowMagSqr = prev2Now.MagnitudeSquared(); |
|
||||||
float start2NowMagSqr = start2Now.MagnitudeSquared(); |
|
||||||
|
|
||||||
float dot = prev2Now.InnerProduct(start2Now); |
|
||||||
|
|
||||||
// HANDLING ANIMATION WRAPPING:
|
|
||||||
// the vector from the animation origin to the current frame should point in roughly
|
|
||||||
// the same direction as the vector from the previous animation position to the
|
|
||||||
// current animation position.
|
|
||||||
//
|
|
||||||
// If they don't agree (dot < 0,) then we probably mpst wrapped around.
|
|
||||||
// The right answer would be to compare the current frame to the start of
|
|
||||||
// the anim loop, but it's cheaper to cheat and return false,
|
|
||||||
// telling the caller to use the previous frame's velocity.
|
|
||||||
if (dot > 0.0f) |
|
||||||
{ |
|
||||||
prev2Now /= elapsed; |
|
||||||
|
|
||||||
float xfabs = fabs(prev2Now.fX); |
|
||||||
float yfabs = fabs(prev2Now.fY); |
|
||||||
float zfabs = fabs(prev2Now.fZ); |
|
||||||
static const float maxVel = 20.0f; |
|
||||||
bool valid = xfabs < maxVel && yfabs < maxVel && zfabs < maxVel; |
|
||||||
|
|
||||||
if (valid) |
|
||||||
{ |
|
||||||
outputV = prev2Now; |
|
||||||
result = true; |
|
||||||
} |
|
||||||
}
|
|
||||||
} |
|
||||||
|
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
static void AngularVelocity(float &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat) |
|
||||||
{ |
|
||||||
outputV = 0.f; |
|
||||||
float appliedVelocity = 0.0f; |
|
||||||
hsVector3 prevForward = GetYAxis(prevMat); |
|
||||||
hsVector3 curForward = GetYAxis(curMat); |
|
||||||
|
|
||||||
float angleSincePrev = AngleRad2d(curForward.fX, curForward.fY, prevForward.fX, prevForward.fY); |
|
||||||
bool sincePrevSign = angleSincePrev > 0.0f; |
|
||||||
if (angleSincePrev > M_PI) |
|
||||||
angleSincePrev = angleSincePrev - TWO_PI; |
|
||||||
|
|
||||||
const hsVector3 startForward = hsVector3(0, -1.0, 0); // the Y orientation of a "resting" armature....
|
|
||||||
float angleSinceStart = AngleRad2d(curForward.fX, curForward.fY, startForward.fX, startForward.fY); |
|
||||||
bool sinceStartSign = angleSinceStart > 0.0f; |
|
||||||
if (angleSinceStart > M_PI) |
|
||||||
angleSinceStart = angleSinceStart - TWO_PI; |
|
||||||
|
|
||||||
// HANDLING ANIMATION WRAPPING:
|
|
||||||
// under normal conditions, the angle from rest to the current frame will have the same
|
|
||||||
// sign as the angle from the previous frame to the current frame.
|
|
||||||
// if it does not, we have (most likely) wrapped the motivating animation from frame n back
|
|
||||||
// to frame zero, creating a large angle from the previous frame to the current one
|
|
||||||
if (sincePrevSign == sinceStartSign) |
|
||||||
{ |
|
||||||
// signs are the same; didn't wrap; use the frame-to-frame angle difference
|
|
||||||
appliedVelocity = angleSincePrev / elapsed; // rotation / time
|
|
||||||
if (fabs(appliedVelocity) < 3) |
|
||||||
{ |
|
||||||
outputV = appliedVelocity; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,217 +0,0 @@ |
|||||||
/*==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/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
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 PL_HK_CALLBACK_ACTION_H |
|
||||||
#define PL_HK_CALLBACK_ACTION_H |
|
||||||
|
|
||||||
#include "hsGeometry3.h" |
|
||||||
#include "hsMatrix44.h" |
|
||||||
#include "hsTemplates.h" |
|
||||||
#include "pnKeyedObject/plKey.h" |
|
||||||
#include "plPhysical/plSimDefs.h" |
|
||||||
#include "pnMessage/plMessage.h" |
|
||||||
#include "plPhysicalControllerCore.h" |
|
||||||
class plLOSHitMsg; |
|
||||||
class plAGApplicator; |
|
||||||
class plSceneObject; |
|
||||||
class plPhysical; |
|
||||||
class plAvatarController; |
|
||||||
class plCoordinateInterface; |
|
||||||
class plPhysicalControllerCore; |
|
||||||
// Used by the other controllers to actually move the avatar. The actual
|
|
||||||
// implementation is in the physics system.
|
|
||||||
/*class plPhysicalController
|
|
||||||
{ |
|
||||||
public: |
|
||||||
// Implemented in the physics system. If you're linking this without that for
|
|
||||||
// some reason, just stub this function out.
|
|
||||||
//
|
|
||||||
// Pass in the key to the root sceneobject for the avatar
|
|
||||||
static plPhysicalController* Create(plKey ownerSO, float height, float width); |
|
||||||
|
|
||||||
virtual ~plPhysicalController() {} |
|
||||||
|
|
||||||
// A disabled avatar doesn't move or accumulate air time if he's off the ground.
|
|
||||||
virtual void Enable(bool enable) = 0; |
|
||||||
virtual bool IsEnabled() const = 0; |
|
||||||
|
|
||||||
// Set the LOS DB this avatar will be in (only one)
|
|
||||||
virtual void SetLOSDB(plSimDefs::plLOSDB losDB) = 0; |
|
||||||
|
|
||||||
// Call this once per frame with the velocities of the avatar in avatar space.
|
|
||||||
virtual void SetVelocities(const hsVector3& linearVel, float angVel) = 0; |
|
||||||
|
|
||||||
// Gets the actual velocity we achieved in the last step (relative to our subworld)
|
|
||||||
virtual const hsVector3& GetLinearVelocity() const = 0; |
|
||||||
virtual void ResetAchievedLinearVelocity() = 0; |
|
||||||
|
|
||||||
// Get and set the current subworld for the avatar. Use nil for the main world.
|
|
||||||
virtual plKey GetSubworld() const = 0; |
|
||||||
virtual void SetSubworld(plKey world) = 0; |
|
||||||
|
|
||||||
// If IsOnGround returns false, GetAirTime will tell you how long the avatar
|
|
||||||
// has been airborne. Use ResetAirTime to reset the air time to zero, for
|
|
||||||
// cases like when the avatar spawns into a new age.
|
|
||||||
virtual bool IsOnGround() const = 0; |
|
||||||
virtual bool IsOnFalseGround() const = 0; |
|
||||||
virtual float GetAirTime() const = 0; |
|
||||||
virtual void ResetAirTime() = 0; |
|
||||||
|
|
||||||
virtual plPhysical* GetPushingPhysical() const = 0; |
|
||||||
virtual bool GetFacingPushingPhysical() const = 0; |
|
||||||
|
|
||||||
// A helper function to get the coordinate interface for the avatars current
|
|
||||||
// world. Handy if you need to convert points to and from that. This will
|
|
||||||
// return nil if the avatar is in the main world (ie, you don't need to do
|
|
||||||
// any translation).
|
|
||||||
virtual const plCoordinateInterface* GetSubworldCI() const = 0; |
|
||||||
|
|
||||||
// For the avatar SDL only
|
|
||||||
virtual void GetState(hsPoint3& pos, float& zRot) = 0; |
|
||||||
virtual void SetState(const hsPoint3& pos, float zRot) = 0; |
|
||||||
|
|
||||||
// kinematic stuff .... should be just for when playing a behavior...
|
|
||||||
virtual void Kinematic(bool state) = 0; |
|
||||||
virtual bool IsKinematic() = 0; |
|
||||||
virtual void GetKinematicPosition(hsPoint3& pos) = 0; |
|
||||||
|
|
||||||
virtual const hsMatrix44& GetPrevSubworldW2L() = 0; |
|
||||||
|
|
||||||
//when seeking no longer want to interact with exclusion regions
|
|
||||||
virtual void SetSeek(bool seek)=0; |
|
||||||
|
|
||||||
|
|
||||||
}; |
|
||||||
*/ |
|
||||||
class plAvatarController |
|
||||||
{ |
|
||||||
public: |
|
||||||
virtual ~plAvatarController() {} |
|
||||||
}; |
|
||||||
|
|
||||||
class plAnimatedController : public plAvatarController |
|
||||||
{ |
|
||||||
public: |
|
||||||
plAnimatedController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller); |
|
||||||
|
|
||||||
virtual void RecalcVelocity(double timeNow, double timePrev, bool useAnim = true); |
|
||||||
void SetTurnStrength(float val) { fTurnStr = val; } |
|
||||||
float GetTurnStrength() { return fTurnStr; } |
|
||||||
virtual void ActivateController()=0; |
|
||||||
protected: |
|
||||||
plSceneObject* fRootObject; |
|
||||||
plPhysicalControllerCore* fController; |
|
||||||
plAGApplicator* fRootApp; |
|
||||||
float fAnimAngVel; |
|
||||||
hsVector3 fAnimPosVel; |
|
||||||
float fTurnStr; // Explicit turning, separate from animations
|
|
||||||
}; |
|
||||||
|
|
||||||
class plWalkingController : public plAnimatedController |
|
||||||
{ |
|
||||||
public: |
|
||||||
plWalkingController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller); |
|
||||||
virtual ~plWalkingController(); |
|
||||||
virtual void RecalcVelocity(double timeNow, double timePrev, bool useAnim = true); |
|
||||||
|
|
||||||
void Reset(bool newAge); |
|
||||||
bool IsControlledFlight() const { return fControlledFlight != 0; }
|
|
||||||
bool IsOnGround() const { return fWalkingStrategy ? fWalkingStrategy->IsOnGround() : true; } |
|
||||||
bool IsOnFalseGround() const { return fWalkingStrategy ? fWalkingStrategy->IsOnFalseGround() : true; } |
|
||||||
bool HitGroundInThisAge() const { return fHitGroundInThisAge; } |
|
||||||
bool EnableControlledFlight(bool status); |
|
||||||
float GetAirTime() const { return fWalkingStrategy ? fWalkingStrategy->GetAirTime() : 0.f; } |
|
||||||
void ResetAirTime() { if (fWalkingStrategy) fWalkingStrategy->ResetAirTime(); } |
|
||||||
float GetForwardVelocity() const; |
|
||||||
void ActivateController(); |
|
||||||
// Check these after the avatar the avatar hits the ground for his total
|
|
||||||
// hangtime and impact velocity.
|
|
||||||
float GetImpactTime() const { return fImpactTime; } |
|
||||||
const hsVector3& GetImpactVelocity() const { return fImpactVelocity; } |
|
||||||
|
|
||||||
plPhysical* GetPushingPhysical() const
|
|
||||||
{ |
|
||||||
if(fController)return fController->GetPushingPhysical();
|
|
||||||
else return nil; |
|
||||||
} |
|
||||||
bool GetFacingPushingPhysical() const
|
|
||||||
{ if(fController)return fController->GetFacingPushingPhysical();
|
|
||||||
else return false; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
protected: |
|
||||||
bool fHitGroundInThisAge; |
|
||||||
bool fWaitingForGround; // We've gone airborne. IsOnGround() returns false until we hit ground again.
|
|
||||||
float fControlledFlightTime; |
|
||||||
int fControlledFlight; // Count of how many are currently forcing flight
|
|
||||||
plWalkingStrategy* fWalkingStrategy; |
|
||||||
float fImpactTime; |
|
||||||
hsVector3 fImpactVelocity; |
|
||||||
bool fClearImpact; |
|
||||||
bool fGroundLastFrame;//used for a test to pass the event of first getting air during a jump
|
|
||||||
static const float kControlledFlightThreshold; |
|
||||||
}; |
|
||||||
class plSwimmingController: public plAnimatedController
|
|
||||||
{ |
|
||||||
public : |
|
||||||
plSwimmingController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller); |
|
||||||
virtual ~plSwimmingController(); |
|
||||||
void SetSurface(plSwimRegionInterface *region, float surfaceHeight){ |
|
||||||
fSwimmingStrategy->SetSurface(region,surfaceHeight); |
|
||||||
} |
|
||||||
float GetBuoyancy() { return fSwimmingStrategy->GetBuoyancy(); } |
|
||||||
bool IsOnGround() { return fSwimmingStrategy->IsOnGround(); } |
|
||||||
bool HadContacts() { return fSwimmingStrategy->HadContacts();} |
|
||||||
void Enable(bool en){if (fController) fController->Enable(en);} |
|
||||||
plPhysicalControllerCore* GetController(){return fController;} |
|
||||||
virtual void ActivateController(){fSwimmingStrategy->RefreshConnectionToControllerCore();} |
|
||||||
protected: |
|
||||||
plSwimStrategy* fSwimmingStrategy; |
|
||||||
|
|
||||||
}; |
|
||||||
class plRidingAnimatedPhysicalController: public plWalkingController |
|
||||||
{ |
|
||||||
public: |
|
||||||
plRidingAnimatedPhysicalController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller); |
|
||||||
virtual ~plRidingAnimatedPhysicalController(); |
|
||||||
}; |
|
||||||
#endif // PL_HK_CALLBACK_ACTION_H
|
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,211 +0,0 @@ |
|||||||
/*==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/>.
|
|
||||||
|
|
||||||
Additional permissions under GNU GPL version 3 section 7 |
|
||||||
|
|
||||||
If you modify this Program, or any covered work, by linking or |
|
||||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
||||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
||||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
||||||
(or a modified version of those libraries), |
|
||||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
||||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
||||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
||||||
licensors of this Program grant you additional |
|
||||||
permission to convey the resulting work. Corresponding Source for a |
|
||||||
non-source form of such a combination shall include the source code for |
|
||||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
||||||
work. |
|
||||||
|
|
||||||
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; |
|
||||||
bool 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_t>& 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 bool 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
|
|
||||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in new issue