CWE-ou-minkata/Sources/Plasma/PubUtilLib/plDrawable/plClusterGroup.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 "plClusterGroup.h"

#include "plSpanTemplate.h"
#include "plCluster.h"

#include "pnMessage/plTimeMsg.h"

#include "plScene/plVisMgr.h"
#include "plScene/plVisRegion.h"

#include "plSurface/hsGMaterial.h"

#include "plGLight/plLightInfo.h"

#include "plDrawableSpans.h"

#include "hsBitVector.h"
#include "hsStream.h"
#include "hsResMgr.h"

//STUB
#include "plgDispatch.h"
#include "plMessage/plAgeLoadedMsg.h"

plClusterGroup::plClusterGroup()
:   fSceneNode(nil),
    fDrawable(nil),
    fTemplate(nil),
    fMaterial(nil),
    fUnPacked(0)
{
    fVisSet.SetBit(plVisMgr::kNormal);
}

plClusterGroup::~plClusterGroup()
{
    int i;
    for( i = 0; i < fClusters.GetCount(); i++ )
        delete fClusters[i];

    delete fTemplate;
}

plCluster* plClusterGroup::IAddCluster()
{
    plCluster* cluster = TRACKED_NEW plCluster;
    // Set the cluster's group.
    cluster->SetGroup(this);
    fClusters.Append(cluster);
    return cluster;
}

plCluster* plClusterGroup::IGetCluster(int i) const
{ 
    return fClusters[i]; 
}

const plCluster* plClusterGroup::GetCluster(int i) const
{ 
    return fClusters[i]; 
}

void plClusterGroup::Read(hsStream* stream, hsResMgr* mgr)
{
    hsKeyedObject::Read(stream, mgr);

    int i;

    fTemplate = TRACKED_NEW plSpanTemplate;
    fTemplate->Read(stream);

    mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefMaterial), plRefFlags::kActiveRef);

    const int numClust = stream->ReadSwap32();
    fClusters.SetCount(numClust);
    for( i = 0; i < numClust; i++ )
    {
        fClusters[i] = TRACKED_NEW plCluster;
        fClusters[i]->Read(stream, this);
    }

    const int numRegions = stream->ReadSwap32();
    for( i = 0; i < numRegions; i++ )
        mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefRegion), plRefFlags::kActiveRef);

    const int numLights = stream->ReadSwap32();
    for( i = 0; i < numLights; i++ )
        mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefLight), plRefFlags::kActiveRef);

    fLOD.Read(stream);

    fRenderLevel.Set(stream->ReadSwap32());

    fSceneNode = mgr->ReadKey(stream);

    //STUB
    plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}

void plClusterGroup::Write(hsStream* stream, hsResMgr* mgr)
{
    hsKeyedObject::Write(stream, mgr);

    int i;

    fTemplate->Write(stream);

    mgr->WriteKey(stream, fMaterial);

    stream->WriteSwap32(fClusters.GetCount());
    for( i = 0; i < fClusters.GetCount(); i++ )
        fClusters[i]->Write(stream);

    stream->WriteSwap32(fRegions.GetCount());
    for( i = 0; i < fRegions.GetCount(); i++ )
        mgr->WriteKey(stream, fRegions[i]);

    stream->WriteSwap32(fLights.GetCount());
    for( i = 0; i < fLights.GetCount(); i++ )
        mgr->WriteKey(stream, fLights[i]);

    fLOD.Write(stream);

    stream->WriteSwap32(fRenderLevel.Level());

    mgr->WriteKey(stream, fSceneNode);
}

void plClusterGroup::ISendToSelf(RefType t, hsKeyedObject* ref)
{
    hsAssert(ref, "Sending self a nil object");
    plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, t);
    hsgResMgr::ResMgr()->SendRef(ref->GetKey(), refMsg, plRefFlags::kActiveRef);
}

hsBool plClusterGroup::IAddVisRegion(plVisRegion* reg)
{
    if( reg )
    {
        int idx = fRegions.Find(reg);
        if( idx == fRegions.kMissingIndex )
        {
            fRegions.Append(reg);
            if( reg->GetProperty(plVisRegion::kIsNot) )
                fVisNot.SetBit(reg->GetIndex());
            else
            {
                fVisSet.SetBit(reg->GetIndex());
                if( reg->ReplaceNormal() )
                    fVisSet.ClearBit(plVisMgr::kNormal);
            }
        }
    }
    return true;
}

hsBool plClusterGroup::IRemoveVisRegion(plVisRegion* reg)
{
    if( reg )
    {
        int idx = fRegions.Find(reg);
        if( fRegions.kMissingIndex != idx )
        {
            fRegions.Remove(idx);
            if( reg->GetProperty(plVisRegion::kIsNot) )
                fVisNot.ClearBit(reg->GetIndex());
            else
                fVisSet.ClearBit(reg->GetIndex());
        }
    }
    return true;
}

hsBool plClusterGroup::IAddLight(plLightInfo* li)
{
    int idx = fLights.Find(li);
    if( fLights.kMissingIndex == idx )
    {
        fLights.Append(li);
    }
    return true;
}

hsBool plClusterGroup::IRemoveLight(plLightInfo* li)
{
    int idx = fLights.Find(li);
    if( fLights.kMissingIndex != idx )
    {
        fLights.Remove(idx);
    }
    return true;
}

hsBool plClusterGroup::IOnReceive(plGenRefMsg* ref)
{
    switch( ref->fType )
    {
    case kRefMaterial:
        fMaterial = hsGMaterial::ConvertNoRef(ref->GetRef());
        return true;
    case kRefRegion:
        return IAddVisRegion(plVisRegion::ConvertNoRef(ref->GetRef()));
    case kRefLight:
        return IAddLight(plLightInfo::ConvertNoRef(ref->GetRef()));
    }
    return false;
}

hsBool plClusterGroup::IOnRemove(plGenRefMsg* ref)
{
    int idx = -1;
    switch( ref->fType )
    {
    case kRefMaterial:
        fMaterial = nil;
        return true;
    case kRefRegion:
        return IRemoveVisRegion(plVisRegion::ConvertNoRef(ref->GetRef()));
    case kRefLight:
        return IRemoveLight(plLightInfo::ConvertNoRef(ref->GetRef()));
    }
    return false;
}

hsBool plClusterGroup::IOnRef(plGenRefMsg* ref)
{
    if( ref->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
    {
        return IOnReceive(ref);
    }

    return IOnRemove(ref);
}

hsBool plClusterGroup::MsgReceive(plMessage* msg)
{
    plGenRefMsg* ref = plGenRefMsg::ConvertNoRef(msg);
    if( ref )
    {
        if( IOnRef(ref) )
            return true;
    }

    // STUB
    plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg);
    if (evalMsg)
    {
        UnPack();
        fUnPacked = true;
        plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey());
        return true;
    }

    return hsKeyedObject::MsgReceive(msg);
}

void plClusterGroup::UnPack()
{
    plDrawableSpans* drawable = TRACKED_NEW plDrawableSpans;
    fDrawable = hsgResMgr::ResMgr()->NewKey(GetKey()->GetName(), drawable, GetKey()->GetUoid().GetLocation());
    drawable->UnPackCluster(this);

    drawable->SetSceneNode(fSceneNode);
}

void plClusterGroup::SetVisible(bool visible)
{
    if (fDrawable)
    {
        plDrawableSpans *drawable = plDrawableSpans::ConvertNoRef(fDrawable->ObjectIsLoaded());
        if (drawable)
            drawable->SetProperty(0,!visible); // property 0 is the disable drawing property
    }
}

UInt32 plClusterGroup::NumInst() const
{
    UInt32 numInst = 0;
    int i;
    for( i = 0; i < fClusters.GetCount(); i++ )
        numInst += fClusters[i]->NumInsts();

    return numInst;
}

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

void plLODDist::Read(hsStream* s)
{
    fMinDist = s->ReadSwapScalar();
    fMaxDist = s->ReadSwapScalar();
}

void plLODDist::Write(hsStream* s) const
{
    s->WriteSwapScalar(fMinDist);
    s->WriteSwapScalar(fMaxDist);
}