CWE-ou-minkata/Sources/Plasma/PubUtilLib/plParticleSystem/plParticleSystem.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 "hsTypes.h"
#include "plParticleSystem.h"
#include "plParticleEmitter.h"
#include "plParticleGenerator.h"
#include "plParticleEffect.h"
#include "plParticle.h"
#include "plParticleSDLMod.h"
#include "plgDispatch.h"
#include "hsResMgr.h"

#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plDrawInterface.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "pnMessage/plTimeMsg.h"
#include "plMessage/plRenderMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "plMessage/plParticleUpdateMsg.h"
#include "plInterp/plController.h"
#include "plSurface/hsGMaterial.h"
#include "plPipeline.h"
#include "hsTimer.h"
#include "plProfile.h"
#include "plTweak.h"

#include "plDrawable/plParticleFiller.h"

plProfile_CreateCounter("Num Particles", "Particles", NumParticles);

const hsScalar plParticleSystem::GRAVITY_ACCEL_FEET_PER_SEC2 = 32.0f;

plParticleSystem::plParticleSystem() : fParticleSDLMod(nil), fAttachedToAvatar(false)
{
}

plParticleSystem::~plParticleSystem()
{
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
    {
        delete fEmitters[i];
    }
    delete [] fEmitters;

    delete fAmbientCtl;
    delete fDiffuseCtl;
    delete fOpacityCtl;
    delete fWidthCtl;
    delete fHeightCtl;
}

void plParticleSystem::Init(UInt32 xTiles, UInt32 yTiles, UInt32 maxTotalParticles, UInt32 maxEmitters, 
                            plController *ambientCtl,   plController *diffuseCtl, plController *opacityCtl, 
                            plController *widthCtl, plController *heightCtl)
{
    fTarget = nil;
    fLastTime = 0;
    fCurrTime = 0;
    SetGravity(1.0f);
    fDrag = 0;
    fWindMult = 1.f;

    fNumValidEmitters = 0;
    fNextEmitterToGo = 0;
    fMiscFlags = 0;

    fForces.Reset();
    fEffects.Reset();
    fConstraints.Reset();

    fXTiles = xTiles;
    fYTiles = yTiles;

    fMaxTotalParticles = fMaxTotalParticlesLeft = maxTotalParticles;
    fMaxEmitters = maxEmitters;
    fEmitters = TRACKED_NEW plParticleEmitter *[fMaxEmitters];
    int i;
    for (i = 0; i < maxEmitters; i++)
        fEmitters[i] = nil; 

    fAmbientCtl = ambientCtl;
    fDiffuseCtl = diffuseCtl;
    fOpacityCtl = opacityCtl;
    fWidthCtl = widthCtl;
    fHeightCtl = heightCtl;
}

void plParticleSystem::IAddEffect(plParticleEffect *effect, UInt32 type)
{
    switch(type)
    {
    case kEffectForce:
        fForces.Append(effect);
        break;
    case kEffectMisc:
    default:
        fEffects.Append(effect);
        break;
    case kEffectConstraint:
        fConstraints.Append(effect);
        break;
    }
}

plParticleEmitter* plParticleSystem::GetAvailEmitter()
{
    if( !fNumValidEmitters ) // got to start with at least one.
        return nil;

    hsScalar minTTL = 1.e33;
    int iMinTTL = -1;
    int i;
    for( i = 0; i < fNumValidEmitters; i++ )
    {
        if( fEmitters[i]->GetTimeToLive() < minTTL )
        {
            minTTL = fEmitters[i]->GetTimeToLive();
            iMinTTL = i;
        }
    }
    if( minTTL > 0 )
    {
        if( fNumValidEmitters < fMaxEmitters )
        {
            minTTL = 0;
            iMinTTL = fNumValidEmitters++;
            fEmitters[iMinTTL] = TRACKED_NEW plParticleEmitter();
            fEmitters[iMinTTL]->Clone(fEmitters[0], iMinTTL);

            fMaxTotalParticlesLeft -= fEmitters[iMinTTL]->fMaxParticles;
            hsAssert(fMaxTotalParticlesLeft >= 0, "Should have planned better");

            // Don't really use this. fEmitters[i]->GetSpanIndex() always == i.
            fNextEmitterToGo = (fNextEmitterToGo + 1) % fMaxEmitters; 
        }
    }
    return fEmitters[iMinTTL];
}

UInt32 plParticleSystem::AddEmitter(UInt32 maxParticles, plParticleGenerator *gen, UInt32 emitterFlags)
{
    if (fMaxEmitters == 0) // silly rabbit, Trix are for kids!
        return 0;
    UInt32 currEmitter;
    if (fNumValidEmitters == fMaxEmitters) // No more free spots, snag the next in line.
    {
        int i;
        for (i = 0; i < fMaxEmitters; i++)
        {
            if (fEmitters[i]->GetSpanIndex() == fNextEmitterToGo)
                break;
        }
        currEmitter = i;

        fMaxTotalParticlesLeft += fEmitters[currEmitter]->fMaxParticles;
        hsAssert(fMaxTotalParticlesLeft <= fMaxTotalParticles, "Particle system somehow has more particles than it started with.");
        delete fEmitters[currEmitter];
    }
    else
    {
        currEmitter = fNumValidEmitters;
        fNumValidEmitters++;
    }

    if (maxParticles > fMaxTotalParticlesLeft)
        maxParticles = fMaxTotalParticlesLeft;
    if (maxParticles < 0)
        maxParticles = 0;

    fEmitters[currEmitter] = TRACKED_NEW plParticleEmitter();
    fEmitters[currEmitter]->Init(this, maxParticles, fNextEmitterToGo, emitterFlags, gen);

    fMaxTotalParticlesLeft -= fEmitters[currEmitter]->fMaxParticles;
    fNextEmitterToGo = (fNextEmitterToGo + 1) % fMaxEmitters;

    return maxParticles;
}

void plParticleSystem::AddParticle(hsPoint3 &pos, hsVector3 &velocity, UInt32 tileIndex, 
                                   hsScalar hSize, hsScalar vSize, hsScalar scale, hsScalar invMass, hsScalar life,
                                   hsPoint3 &orientation, UInt32 miscFlags, hsScalar radsPerSec)
{
    hsAssert(fNumValidEmitters > 0, "Trying to explicitly add particles to a system with no valid emitters.");
    if (fNumValidEmitters == 0)
        return;

    fEmitters[0]->AddParticle(pos, velocity, tileIndex, hSize, vSize, scale, invMass, life, orientation, miscFlags, radsPerSec);
}

void plParticleSystem::GenerateParticles(UInt32 num, hsScalar dt /* = 0.f */)
{
    if (num <= 0)
        return;

    if (fNumValidEmitters > 0 && fEmitters[0]->fGenerator)
        fEmitters[0]->fGenerator->AddAutoParticles(fEmitters[0], dt, num);

    GetTarget(0)->DirtySynchState(kSDLParticleSystem, 0);   
}

void plParticleSystem::WipeExistingParticles()
{
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
        fEmitters[i]->WipeExistingParticles();
}

void plParticleSystem::KillParticles(hsScalar num, hsScalar timeToDie, UInt8 flags)
{
    if (fEmitters[0])
        fEmitters[0]->KillParticles(num, timeToDie, flags);

    GetTarget(0)->DirtySynchState(kSDLParticleSystem, 0);   
}

void plParticleSystem::TranslateAllParticles(hsPoint3 &amount)
{
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
        fEmitters[i]->TranslateAllParticles(amount);
}

void plParticleSystem::DisableGenerators()
{
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
        fEmitters[i]->UpdateGenerator(plParticleUpdateMsg::kParamEnabled, 0.f);
}

UInt16 plParticleSystem::StealParticlesFrom(plParticleSystem *victim, UInt16 num)
{
    if (fNumValidEmitters <= 0)
        return 0; // you just lose

    if (victim)
    {
        UInt16 numStolen = fEmitters[0]->StealParticlesFrom(victim->fNumValidEmitters > 0 ? victim->fEmitters[0] : nil, num);
        GetTarget(0)->DirtySynchState(kSDLParticleSystem, 0);   
        victim->GetTarget(0)->DirtySynchState(kSDLParticleSystem, 0);   
        return numStolen;
    }
    
    return 0;
}

plParticleGenerator *plParticleSystem::GetExportedGenerator() const 
{ 
    return (fNumValidEmitters > 0 ? fEmitters[0]->fGenerator : nil);
}

plParticleEffect *plParticleSystem::GetEffect(UInt16 type) const
{
    int i;
    for (i = 0; i < fForces.GetCount(); i++)
        if (fForces[i]->ClassIndex() == type)
            return fForces[i];

    for (i = 0; i < fEffects.GetCount(); i++)
        if (fEffects[i]->ClassIndex() == type)
            return fEffects[i];

    for (i = 0; i < fConstraints.GetCount(); i++)
        if (fConstraints[i]->ClassIndex() == type)
            return fConstraints[i];

    return nil;
}

UInt32 plParticleSystem::GetNumValidParticles(hsBool immortalOnly /* = false */) const
{
    UInt32 count = 0;
    int i, j;
    for (i = 0; i < fNumValidEmitters; i++)
    {
        if (immortalOnly)
        {
            for (j = 0; j < fEmitters[i]->fNumValidParticles; j++)
            {
                if (fEmitters[i]->fParticleExts[j].fMiscFlags & plParticleExt::kImmortal)
                    count++;
            }
        }
        else
            count += fEmitters[i]->fNumValidParticles;
    }
    return count;
}


const hsMatrix44 &plParticleSystem::GetLocalToWorld() const
{ 
    return fTarget->GetCoordinateInterface()->GetLocalToWorld(); 
}

hsBool plParticleSystem::IEval(double secs, hsScalar del, UInt32 dirty)
{
    return false;
}



hsBool plParticleSystem::IShouldUpdate(plPipeline* pipe) const
{

    if (fMiscFlags & kParticleSystemAlwaysUpdate)
        return true;

    if (IGetTargetDrawInterface(0) && IGetTargetDrawInterface(0)->GetProperty(plDrawInterface::kDisable))
        return false;

    // First, what are the cumulative bounds for this system.
    hsBounds3Ext wBnd;
    wBnd.MakeEmpty();
    int i;
    for( i = 0; i < fNumValidEmitters; i++ )
    {
        if( fEmitters[i]->GetBoundingBox().GetType() == kBoundsNormal )
            wBnd.Union(&fEmitters[i]->GetBoundingBox());
    }

    // Always update if we are currently empty
    if( wBnd.GetType() == kBoundsEmpty )
    {
        return true;
    }

    // Now, are we visible?
    hsBool isVisible = pipe->TestVisibleWorld(wBnd);

    hsScalar delta = fLastTime > 0 ? hsScalar(fCurrTime - fLastTime) : hsTimer::GetDelSysSeconds();
    if( isVisible )
    {
        // If we know how fast the fastest particle is moving, then we can
        // decide if the system is too far away to need to update every single frame.
        // In fact, based on the speed of the fastest particle, we can determine an
        // exact update rate for a given error (say 3 pixels?).
        // But we don't currently know the speed of the fastest particle, so
        // until we do, I'm commenting this out. Most of the speed gain from
        // culling particle updates was from not updating systems that aren't visible
        // anyway.
#if 0 // ALWAYS_IF_VISIBLE
        // We're in view, but how close are we to the camera? Look at closest point.
        hsPoint2 depth;
        wBnd.TestPlane(pipe->GetViewDirWorld(), depth);
        hsScalar eyeDist = pipe->GetViewDirWorld().InnerProduct(pipe->GetViewPositionWorld());
        hsScalar dist = depth.fX - eyeDist;

        static hsScalar kUpdateCutoffDist = 100.f;
        if( dist > kUpdateCutoffDist )
        {
            static hsScalar kDistantUpdateSecs = 0.1f;
            return delta >= kDistantUpdateSecs;
        }
#endif // ALWAYS_IF_VISIBLE

        return true;
    }
    

    static hsScalar kOffscreenUpdateSecs = 1.f;
    return delta >= kOffscreenUpdateSecs;
}

plDrawInterface* plParticleSystem::ICheckDrawInterface()
{
    plDrawInterface* di = IGetTargetDrawInterface(0);
    if( !di )
        return nil;

    if( di->GetDrawableMeshIndex(0) == UInt32(-1) )
    {
        di->SetUpForParticleSystem( fMaxEmitters + 1, fMaxTotalParticles, fTexture, fPermaLights );
        hsAssert(di->GetDrawableMeshIndex( 0 ) != (UInt32)-1, "SetUpForParticleSystem should never fail"); // still invalid, didn't fix it.
    }

    return di;
}

void plParticleSystem::IHandleRenderMsg(plPipeline* pipe)
{   
    fCurrTime = hsTimer::GetSysSeconds(); 
    hsScalar delta = hsScalar(fCurrTime - fLastTime);
    if (delta == 0)
        return;
    plConst(hsScalar) kMaxDelta(0.3f);
    if( delta > kMaxDelta )
        delta = kMaxDelta;

    plDrawInterface* di = ICheckDrawInterface();
    if( !di )
        return;

    hsBool disabled = di->GetProperty(plDrawInterface::kDisable);
    if (!IShouldUpdate(pipe))
    {
        if (disabled)
            di->ResetParticleSystem(); // Need to call this, otherwise particles get drawn, even though the DI is disabled.
                                       // (Yes, it's lame.)

        // Otherwise, we leave the DI alone, and the particles draw in the same place they were last frame.
        return;
    }

    fContext.fPipeline = pipe;
    fContext.fSystem = this;
    fContext.fSecs = fCurrTime;
    fContext.fDelSecs = delta;

    di->ResetParticleSystem();

    if (fPreSim > 0)
        IPreSim();
    
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
    {
        fEmitters[i]->IUpdate(delta);
        plProfile_IncCount(NumParticles, fEmitters[i]->fNumValidParticles);
        if (!disabled)
        {
            if( fEmitters[ i ]->GetParticleCount() > 0 )
                di->AssignEmitterToParticleSystem( fEmitters[ i ] ); // Go make those polys!
        }
    }
    
//  plParticleFiller::FillParticlePolys(pipe, di);

    fLastTime = fCurrTime;
}


#include "plProfile.h"
plProfile_CreateTimer("ParticleSys", "RenderSetup", ParticleSys);


hsBool plParticleSystem::MsgReceive(plMessage* msg)
{
    plGenRefMsg* refMsg;
    plParticleUpdateMsg *partMsg;
    plParticleKillMsg *killMsg;
    plSceneObject *scene;
    plParticleEffect *effect;
    hsGMaterial *mat;
    plRenderMsg *rend;
    plAgeLoadedMsg* ageLoaded;

    if (rend = plRenderMsg::ConvertNoRef(msg))
    {
        plProfile_BeginLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName());
        IHandleRenderMsg(rend->Pipeline());
        plProfile_EndLap(ParticleSys, this->GetKey()->GetUoid().GetObjectName());
        return true;
    }
    else if (refMsg = plGenRefMsg::ConvertNoRef(msg))
    {
        if (scene = plSceneObject::ConvertNoRef(refMsg->GetRef()))
        {
            if (refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace))
                AddTarget(scene);
            else
                RemoveTarget(scene);
            return true;
        }
        if (mat = hsGMaterial::ConvertNoRef(refMsg->GetRef()))
        {
            if (refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace))
                fTexture = mat;
            else
                fTexture = nil;
            return true;
        }
        if (effect = plParticleEffect::ConvertNoRef(refMsg->GetRef()))
        {
            if (refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace))
                IAddEffect(effect, refMsg->fType);
            //else
            //  IRemoveEffect(effect, refMsg->fType);
            return true;
        }
    }
    else if (partMsg = plParticleUpdateMsg::ConvertNoRef(msg))
    {
        UpdateGenerator(partMsg->GetParamID(), partMsg->GetParamValue());
        return true;
    }
    else if (killMsg = plParticleKillMsg::ConvertNoRef(msg)) 
    {
        KillParticles(killMsg->fNumToKill, killMsg->fTimeLeft, killMsg->fFlags);
        return true;
    }
    else if( (ageLoaded = plAgeLoadedMsg::ConvertNoRef(msg)) && ageLoaded->fLoaded )
    {
        ICheckDrawInterface();
        return true;
    }
    return plModifier::MsgReceive(msg);
}

void plParticleSystem::UpdateGenerator(UInt32 paramID, hsScalar value)
{
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
        fEmitters[i]->UpdateGenerator(paramID, value);
}

void plParticleSystem::AddTarget(plSceneObject *so)
{
    if (fTarget != nil)
        RemoveTarget(fTarget);

    fTarget = so;
    plgDispatch::Dispatch()->RegisterForExactType(plTimeMsg::Index(), GetKey());
    plgDispatch::Dispatch()->RegisterForExactType(plRenderMsg::Index(), GetKey());
    plgDispatch::Dispatch()->RegisterForExactType(plAgeLoadedMsg::Index(), GetKey());

    delete fParticleSDLMod;
    fParticleSDLMod = TRACKED_NEW plParticleSDLMod;
    fParticleSDLMod->SetAttachedToAvatar(fAttachedToAvatar);
    so->AddModifier(fParticleSDLMod);
}

void plParticleSystem::RemoveTarget(plSceneObject *so)
{
    if (so == fTarget && so != nil)
    {
        if (fParticleSDLMod)
        {
            so->RemoveModifier(fParticleSDLMod);
            delete fParticleSDLMod;
            fParticleSDLMod = nil;
        }
        fTarget = nil;
    }
}

// This can be done much faster, but it's only done on load, and very very clean as is. Saving optimization for
// when we observe that it's too slow.
void plParticleSystem::IPreSim()
{
    const double PRESIM_UPDATE_TICK = 0.1;

    int i;
    for (i = 0; i < fNumValidEmitters; i++)
    {
        double secs = fPreSim;
        while (secs > 0)
        {
            fEmitters[i]->IUpdateParticles((hsScalar)PRESIM_UPDATE_TICK);
            secs -= PRESIM_UPDATE_TICK;
        }
    }

    fPreSim = 0;
}

void plParticleSystem::IReadEffectsArray(hsTArray<plParticleEffect *> &effects, UInt32 type, hsStream *s, hsResMgr *mgr)
{
    plGenRefMsg *msg;
    effects.Reset();
    UInt32 count = s->ReadSwap32();
    int i;
    for (i = 0; i < count; i++)
    {
        msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, (Int8)type);
        mgr->ReadKeyNotifyMe(s, msg, plRefFlags::kActiveRef);
    }
}

void plParticleSystem::Read(hsStream *s, hsResMgr *mgr)
{
    plModifier::Read(s, mgr);

    plGenRefMsg* msg;
    msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, 0); // Material
    mgr->ReadKeyNotifyMe(s, msg, plRefFlags::kActiveRef);

    fAmbientCtl = plController::ConvertNoRef(mgr->ReadCreatable(s));    
    fDiffuseCtl = plController::ConvertNoRef(mgr->ReadCreatable(s));
    fOpacityCtl = plController::ConvertNoRef(mgr->ReadCreatable(s));
    fWidthCtl = plController::ConvertNoRef(mgr->ReadCreatable(s));
    fHeightCtl = plController::ConvertNoRef(mgr->ReadCreatable(s));

    UInt32 xTiles = s->ReadSwap32();
    UInt32 yTiles = s->ReadSwap32();
    UInt32 maxTotal = s->ReadSwap32();
    UInt32 maxEmitters = s->ReadSwap32();
    Init(xTiles, yTiles, maxTotal, maxEmitters, fAmbientCtl, fDiffuseCtl, fOpacityCtl, fWidthCtl, fHeightCtl);

    fPreSim = s->ReadSwapScalar();
    fAccel.Read(s);
    fDrag = s->ReadSwapScalar();
    fWindMult = s->ReadSwapScalar();

    fNumValidEmitters = s->ReadSwap32();
    int i;
    for (i = 0; i < fNumValidEmitters; i++)
    {
        fEmitters[i] = plParticleEmitter::ConvertNoRef(mgr->ReadCreatable(s));
        fEmitters[i]->ISetSystem(this);
    }

    IReadEffectsArray(fForces, kEffectForce, s, mgr);
    IReadEffectsArray(fEffects, kEffectMisc, s, mgr);
    IReadEffectsArray(fConstraints, kEffectConstraint, s, mgr);

    int count = s->ReadSwap32();
    fPermaLights.SetCount(count);
    for( i = 0; i < count; i++ )
    {
        fPermaLights[i] = mgr->ReadKey(s);
    }
}

void plParticleSystem::Write(hsStream *s, hsResMgr *mgr)
{
    plModifier::Write(s, mgr);

    int i;

    mgr->WriteKey(s, fTexture);

    // Arguments to the Init() function
    mgr->WriteCreatable(s, fAmbientCtl);
    mgr->WriteCreatable(s, fDiffuseCtl);
    mgr->WriteCreatable(s, fOpacityCtl);
    mgr->WriteCreatable(s, fWidthCtl);
    mgr->WriteCreatable(s, fHeightCtl);
    
    s->WriteSwap32(fXTiles);
    s->WriteSwap32(fYTiles);
    s->WriteSwap32(fMaxTotalParticles);
    s->WriteSwap32(fMaxEmitters);

    s->WriteSwapScalar(fPreSim);
    fAccel.Write(s);
    s->WriteSwapScalar(fDrag);
    s->WriteSwapScalar(fWindMult);

    s->WriteSwap32(fNumValidEmitters);
    for (i = 0; i < fNumValidEmitters; i++)
    {
        mgr->WriteCreatable(s, fEmitters[i]);
    }

    int count;
    count = fForces.GetCount();
    s->WriteSwap32(count);
    for (i = 0; i < count; i++)
        mgr->WriteKey(s, fForces.Get(i));

    count = fEffects.GetCount();
    s->WriteSwap32(count);
    for (i = 0; i < count; i++)
        mgr->WriteKey(s, fEffects.Get(i));

    count = fConstraints.GetCount();
    s->WriteSwap32(count);
    for (i = 0; i < count; i++)
        mgr->WriteKey(s, fConstraints.Get(i));

    count = fPermaLights.GetCount();
    s->WriteSwap32(count);
    for( i = 0; i < count; i++ )
        mgr->WriteKey(s, fPermaLights[i]);
}

void plParticleSystem::SetAttachedToAvatar(bool attached)
{
    fAttachedToAvatar = attached;
    if (fParticleSDLMod)
        fParticleSDLMod->SetAttachedToAvatar(attached);
}

void plParticleSystem::AddLight(plKey liKey)
{
    fPermaLights.Append(liKey);
}