CWE-ou-minkata/Sources/Plasma/PubUtilLib/plPhysical/plPhysicsSoundMgr.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==*/
#include <algorithm>
#include <iterator>
#include "hsTimer.h"
#include "plPhysicsSoundMgr.h"
#include "plPhysicalSndGroup.h"
#include "pnKeyedObject/plFixedKey.h"
#include "plStatusLog/plStatusLog.h"
#include "plMessage/plAnimCmdMsg.h"
#include "pfAudio/plRandomSoundMod.h"

#define MIN_VOLUME 0.0001f

void plPhysicsSoundMgr::AddContact(plPhysical* phys1, plPhysical* phys2, const hsPoint3& hitPoint, const hsVector3& hitNormal)
{
    CollidePair cp(phys1->GetKey(), phys2->GetKey(), hitPoint, hitNormal);
    fCurCollisions.insert(cp);
}

void plPhysicsSoundMgr::Update()
{
    // Get all the physicals that only in the new list (started colliding)
    CollideSet startedColliding;
    std::set_difference(fCurCollisions.begin(), fCurCollisions.end(),
        fPrevCollisions.begin(), fPrevCollisions.end(),
        std::inserter(startedColliding, startedColliding.begin()));

    for (CollideSet::iterator it = startedColliding.begin(); it != startedColliding.end(); it++)
        IStartCollision(*it);

    for (CollideSet::iterator it = fPrevCollisions.begin(); it != fPrevCollisions.end(); it++)
    {
        CollideSet::iterator old = fCurCollisions.find(*it);
        if (old != fCurCollisions.end())
        {
            IUpdateCollision(*it);
        }
        else
        {
            IStopCollision(*it);
        }
    }

    fPrevCollisions = fCurCollisions;
    fCurCollisions.clear();
}

void plPhysicsSoundMgr::IStartCollision(const CollidePair& cp)
{
    hsVector3 v1, v2;
    const hsScalar strengthThreshold = 20.0f;

    plPhysical* physicalA = cp.FirstPhysical();
    plPhysical* physicalB = cp.SecondPhysical();
    if (!physicalA || !physicalB)
        return;

    plPhysicalSndGroup* sndA = physicalA->GetSoundGroup();
    plPhysicalSndGroup* sndB = physicalB->GetSoundGroup();

    // If no impact sounds were specified in max don't do anything here.
    if (!sndA->HasImpactSound(sndB->GetGroup()) &&
        !sndB->HasImpactSound(sndA->GetGroup()))
        return;

    physicalA->GetLinearVelocitySim(v1);
    physicalB->GetLinearVelocitySim(v2);
    hsVector3 vel = v1 - v2;
    hsScalar strength = vel.MagnitudeSquared();
    
    if (strength >= strengthThreshold)
    {
        if (sndA->HasImpactSound(sndB->GetGroup()))
        {
            sndA->PlayImpactSound(sndB->GetGroup());
        }
        else
        {
            sndB->PlayImpactSound(sndA->GetGroup());
        }
    }
}

void plPhysicsSoundMgr::IStopCollision(const CollidePair& cp)
{
    plPhysical* physicalA = cp.FirstPhysical();
    plPhysical* physicalB = cp.SecondPhysical();
    if (physicalA && physicalB)
    {
        plPhysicalSndGroup* sndA = physicalA->GetSoundGroup();
        plPhysicalSndGroup* sndB = physicalB->GetSoundGroup();

        if (sndA->HasSlideSound(sndB->GetGroup()))
        {
            if(sndA->IsSliding())
            {
                sndA->StopSlideSound(sndB->GetGroup()); 
            }
        }
        if (sndB->HasSlideSound(sndA->GetGroup()))
        {
            if(sndB->IsSliding())
            {
                sndB->StopSlideSound(sndA->GetGroup());     
            }
        }
    }
}

void plPhysicsSoundMgr::IUpdateCollision(const CollidePair& cp)
{
    const hsScalar slideThreshhold = 0.f;   
    hsVector3 v1, v2;
    plPhysical* physicalA = cp.FirstPhysical();
    plPhysical* physicalB = cp.SecondPhysical();
    if (!physicalA || !physicalB)
        return;

    plPhysicalSndGroup* sndA = physicalA->GetSoundGroup();
    plPhysicalSndGroup* sndB = physicalB->GetSoundGroup();

    physicalA->GetLinearVelocitySim(v1);
    physicalB->GetLinearVelocitySim(v2);
    hsVector3 vel = v1 - v2;
    hsScalar strength = vel.MagnitudeSquared();
    
    // scale strength to use as volume
    strength /= 16*8;
    if(strength < MIN_VOLUME)
        strength = 0;
    
    if (sndA->HasSlideSound(sndB->GetGroup()))
        IProcessSlide(sndA, sndB, strength);
    else
        IProcessSlide(sndB, sndA, strength);
}

void plPhysicsSoundMgr::IProcessSlide(plPhysicalSndGroup* sndA, plPhysicalSndGroup* sndB, hsScalar strength)
{
    sndA->SetSlideSoundVolume(sndB->GetGroup(), strength);

    if(strength > MIN_VOLUME)
    {
        if(!sndA->IsSliding())
        {
            sndA->PlaySlideSound(sndB->GetGroup());
        }
    }
}

//////////////////////////////////////////////////////////////////////////

plPhysicsSoundMgr::CollidePair::CollidePair(const plKey& firstPhys, const plKey& secondPhys, const hsPoint3& point, const hsVector3& normal)
{
    // To simplify searching and sorting, all pairs are set up with the pointer value of the
    // first element greater than the pointer value of the second.
    if (firstPhys->GetObjectPtr() < secondPhys->GetObjectPtr())
    {
        this->firstPhysKey = secondPhys;
        this->secondPhysKey = firstPhys;
    }
    else
    {
        this->firstPhysKey = firstPhys;
        this->secondPhysKey = secondPhys;
    }

    this->point = point;
    this->normalForce = normal;
}

bool plPhysicsSoundMgr::CollidePair::operator<(const CollidePair& rhs) const
{
    return (firstPhysKey->GetObjectPtr() < rhs.firstPhysKey->GetObjectPtr() 
        || (rhs.firstPhysKey->GetObjectPtr() == firstPhysKey->GetObjectPtr() && secondPhysKey->GetObjectPtr() < rhs.secondPhysKey->GetObjectPtr()));
}

bool plPhysicsSoundMgr::CollidePair::operator==(const CollidePair& rhs) const
{
    if (firstPhysKey == rhs.firstPhysKey && secondPhysKey == rhs.secondPhysKey)
        return true;
    return false;
}

plPhysical* plPhysicsSoundMgr::CollidePair::FirstPhysical() const
{
    return firstPhysKey ? static_cast<plPhysical*>(firstPhysKey->GetObjectPtr()) : nil;
}

plPhysical* plPhysicsSoundMgr::CollidePair::SecondPhysical() const
{
    return secondPhysKey ? static_cast<plPhysical*>(secondPhysKey->GetObjectPtr()) : nil;
}