Browse Source
plMovementStrategy classes have been reworked and completely replace all plAvatarControllers. While based on the old implementation, plPhysicalControllerCore has essentially been rewritten. Remnants of long gone physical "actions" have been removed. 4 files removed - plAVCallbackAction.h & plAVCallbackAction.cpp plAntiGravAction.h & plAntiGravAction.cpp This revision will not compile, requires new plPXPhysicalControllerCore implementation.avatar-physics
Skoader
13 years ago
35 changed files with 989 additions and 2428 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); |
||||
hsScalar angCurrent = 0.f; |
||||
if (fCurrentRegion != nil) |
||||
fCurrentRegion->GetCurrent(fPhysical, linCurrent, angCurrent, (hsScalar)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);
|
||||
hsScalar 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, hsScalar 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, hsScalar surfaceHeight); |
||||
hsScalar GetBuoyancy() { return fBuoyancy; } |
||||
hsBool IsOnGround() { return fOnGround; } |
||||
hsBool HadContacts() { return fHadContacts; } |
||||
|
||||
protected: |
||||
void IAdjustBuoyancy(); |
||||
|
||||
hsBool fOnGround; |
||||
hsBool fHadContacts; |
||||
hsScalar fBuoyancy; |
||||
hsScalar 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.
|
||||
hsBool LinearVelocity(hsVector3 &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat); |
||||
void AngularVelocity(hsScalar &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat); |
||||
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, hsBool 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 hsScalar 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= TRACKED_NEW plWalkingStrategy(fController); |
||||
fController->SetMovementSimulationInterface(fWalkingStrategy); |
||||
} |
||||
else |
||||
fWalkingStrategy = nil; |
||||
} |
||||
|
||||
void plWalkingController::RecalcVelocity(double timeNow, double timePrev, hsBool 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
|
||||
// LinearVelocity is always (0,0,0) outside the PhysController
|
||||
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= TRACKED_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);
|
||||
//
|
||||
// hsBool isPhysical = !fPhysical->GetProperty(plSimulationInterface::kPinned);
|
||||
// const Havok::Vector3 straightUp(0.0f, 0.0f, 1.0f);
|
||||
// hsBool 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); |
||||
hsScalar 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 hsScalar threshold = hsScalarDegToRad(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] = hsATan2(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]) |
||||
{ |
||||
hsScalar 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 * hsScalarPI))) |
||||
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 += (hsScalar)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 = (hsScalar)(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 += (hsScalar)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); |
||||
hsScalar 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= TRACKED_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 = TRACKED_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 hsBool 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; |
||||
hsBool valid = xfabs < maxVel && yfabs < maxVel && zfabs < maxVel; |
||||
|
||||
if (valid) |
||||
{ |
||||
outputV = prev2Now; |
||||
result = true; |
||||
} |
||||
}
|
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
static void AngularVelocity(hsScalar &outputV, float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat) |
||||
{ |
||||
outputV = 0.f; |
||||
hsScalar appliedVelocity = 0.0f; |
||||
hsVector3 prevForward = GetYAxis(prevMat); |
||||
hsVector3 curForward = GetYAxis(curMat); |
||||
|
||||
hsScalar angleSincePrev = AngleRad2d(curForward.fX, curForward.fY, prevForward.fX, prevForward.fY); |
||||
hsBool sincePrevSign = angleSincePrev > 0.0f; |
||||
if (angleSincePrev > hsScalarPI) |
||||
angleSincePrev = angleSincePrev - TWO_PI; |
||||
|
||||
const hsVector3 startForward = hsVector3(0, -1.0, 0); // the Y orientation of a "resting" armature....
|
||||
hsScalar angleSinceStart = AngleRad2d(curForward.fX, curForward.fY, startForward.fX, startForward.fY); |
||||
hsBool sinceStartSign = angleSinceStart > 0.0f; |
||||
if (angleSinceStart > hsScalarPI) |
||||
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, hsScalar height, hsScalar 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, hsScalar 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 hsScalar 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, hsBool useAnim = true); |
||||
void SetTurnStrength(hsScalar val) { fTurnStr = val; } |
||||
hsScalar GetTurnStrength() { return fTurnStr; } |
||||
virtual void ActivateController()=0; |
||||
protected: |
||||
plSceneObject* fRootObject; |
||||
plPhysicalControllerCore* fController; |
||||
plAGApplicator* fRootApp; |
||||
hsScalar fAnimAngVel; |
||||
hsVector3 fAnimPosVel; |
||||
hsScalar 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, hsBool 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); |
||||
hsScalar GetAirTime() const { return fWalkingStrategy ? fWalkingStrategy->GetAirTime() : 0.f; } |
||||
void ResetAirTime() { if (fWalkingStrategy) fWalkingStrategy->ResetAirTime(); } |
||||
hsScalar GetForwardVelocity() const; |
||||
void ActivateController(); |
||||
// Check these after the avatar the avatar hits the ground for his total
|
||||
// hangtime and impact velocity.
|
||||
hsScalar 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.
|
||||
hsScalar fControlledFlightTime; |
||||
int fControlledFlight; // Count of how many are currently forcing flight
|
||||
plWalkingStrategy* fWalkingStrategy; |
||||
hsScalar fImpactTime; |
||||
hsVector3 fImpactVelocity; |
||||
bool fClearImpact; |
||||
bool fGroundLastFrame;//used for a test to pass the event of first getting air during a jump
|
||||
static const hsScalar kControlledFlightThreshold; |
||||
}; |
||||
class plSwimmingController: public plAnimatedController
|
||||
{ |
||||
public : |
||||
plSwimmingController(plSceneObject* rootObject, plAGApplicator* rootApp, plPhysicalControllerCore* controller); |
||||
virtual ~plSwimmingController(); |
||||
void SetSurface(plSwimRegionInterface *region, hsScalar surfaceHeight){ |
||||
fSwimmingStrategy->SetSurface(region,surfaceHeight); |
||||
} |
||||
hsScalar GetBuoyancy() { return fSwimmingStrategy->GetBuoyancy(); } |
||||
hsBool IsOnGround() { return fSwimmingStrategy->IsOnGround(); } |
||||
hsBool 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
Loading…
Reference in new issue