CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plAntiGravAction.cpp

/*==LICENSE==*

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

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

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

*==LICENSE==*/
#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