CWE-ou-minkata/Sources/Tools/MaxSceneViewer/SceneWatcher.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 "SceneWatcher.h"

#include "../MaxMain/plMaxNode.h"
#include "../MaxComponent/plComponent.h"
#include "../MaxMain/plPlasmaRefMsgs.h"

#include "../pnKeyedObject/plKey.h"

SceneWatcher::SceneWatcher() : fDirty(false)
{
    RegisterNotification(INotify, this, NOTIFY_NODE_CREATED);
    IAddNodeRecur((plMaxNode*)GetCOREInterface()->GetRootNode());
}

SceneWatcher::~SceneWatcher()
{
    DeleteAllRefsFromMe();
    UnRegisterNotification(INotify, this, NOTIFY_NODE_CREATED);
}

int SceneWatcher::NumRefs()
{
    return fNodes.size();
}

RefTargetHandle SceneWatcher::GetReference(int i)
{
    if (i < fNodes.size())
        return fNodes[i];

    hsAssert(0, "Index out of range");
    return nil;
}

void SceneWatcher::SetReference(int i, RefTargetHandle rtarg)
{
    if (i < fNodes.size())
        fNodes[i] = (plMaxNode*)rtarg;
    else
        hsAssert(0, "Index out of range");
}

//
// Something in the scene has changed.
//
RefResult SceneWatcher::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 
                           PartID& partID, RefMessage message)
{
    plMaxNode *node = (plMaxNode *)hTarget;

#ifdef HS_DEBUGGING
    char *tmp = node->GetName();
#endif

    if (message == REFMSG_CHANGE)
    {
        // If the message is from a component, and was not generated locally (ie.
        // it came from a ref parameter), ignore it.  There is no way to tell if
        // one of these messages is an actual change to the component or just a
        // change to the referenced object.  We'll catch the real changes with
        // REFMSG_USER_COMP_REF_CHANGED below.
        if (node->IsComponent())
        {
            plComponentBase *comp = node->ConvertToComponent();
            if (!comp->IsCurMsgLocal())
                return REF_SUCCEED;
        }

        // If this is a static light, ignore it
        Object *obj = node->GetObjectRef();
        if (obj && obj->SuperClassID() == LIGHT_CLASS_ID && !node->GetRunTimeLight())
            return REF_SUCCEED;

        node->SetDirty(plMaxNode::kGeomDirty, true);
        ISetDirty();
    }
    else if (message == REFMSG_TARGET_DELETED)
    {
        // If the deleted node was a component, dirty everyone it was attached to
        if (node->IsComponent())
        {
            plComponentBase *comp = node->ConvertToComponent();
            for (UInt32 i = 0; i < comp->NumTargets(); i++)
            {
                if (comp->GetTarget(i))
                    comp->GetTarget(i)->SetDirty(plMaxNode::kGeomDirty, true);
            }
        }

        fDeleted.push_back(node->GetKey());

        IRemoveRef(node);
        ISetDirty();
    }
    else if (message == REFMSG_NODE_MATERIAL_CHANGED ||
            message == REFMSG_USER_MAT)
    {
        if (!node->IsComponent())
        {
            node->SetDirty(plMaxNode::kMatDirty, true);
            ISetDirty();
        }
    }
    // A node was added to the components target list
    else if (message == REFMSG_USER_TARGET_ADD)
    {
        plMaxNode *target = (plMaxNode*)partID;
        target->SetDirty(plMaxNode::kGeomDirty, true);
        ISetDirty();
    }
    // A node was deleted from the components target list
    else if (message == REFMSG_USER_TARGET_DELETE)
    {
        plMaxNode *target = (plMaxNode*)partID;
        target->SetDirty(plMaxNode::kGeomDirty, true);
        ISetDirty();
    }
    // A ref maintained by a component PB changed (not just a propagated message
    // from the ref)
    else if (message == REFMSG_USER_COMP_REF_CHANGED)
    {
        node->SetDirty(plMaxNode::kGeomDirty, true);
        ISetDirty();
    }

    return REF_SUCCEED;
}

bool SceneWatcher::AnyDeleted()
{
    return !fDeleted.empty();
}

SceneWatcher::KeyList& SceneWatcher::GetDeleted()
{
    return fDeleted;
}

const SceneWatcher::NodeList& SceneWatcher::GetWatchNodes()
{
    return fNodes;
}

bool SceneWatcher::AnyDirty()
{
    return fDirty;
}

void SceneWatcher::GetDirty(NodeSet& dirtyNodes)
{
    int size = fNodes.size();
    for (int i = 0; i < size; i++)
    {
        plMaxNode *node = fNodes[i];

#ifdef HS_DEBUGGING
        const char *tmp = node ? node->GetName() : nil;
#endif
        // If any dirty flags are set, add to dirty list
        if (node && node->GetDirty(plMaxNode::kAllDirty))
            IGetDependents(node, dirtyNodes);
    }

    fDirty = false;
}

void SceneWatcher::IAddRef(plMaxNode *node)
{
    // Ensure that we don't already ref this node
    if (FindRef(node) != -1)
        return;

    // Make a ref
    int size = fNodes.size();
    fNodes.resize(size+1);
    MakeRefByID(FOREVER, size, node);
}

void SceneWatcher::IRemoveRef(plMaxNode *node)
{
    // Delete the reference if it's in our list
    int i = FindRef(node);

    if (i != -1)
    {
        // Clear the node data, in case it is undeleted later
        // (when it will be invalid)
        node->ClearData(nil, nil);
        node->SetDirty(plMaxNode::kAllDirty, true);

        // We can never really delete this reference because the user may "undo"
        // and cause it to come back, which just sets the reference again.
        fNodes[i] = nil;
    }
}

void SceneWatcher::IAddNodeRecur(plMaxNode *node)
{
    IAddRef(node);

    // If a node is dirty, make sure to set the dirty flag (since nodes may have
    // been dirtied in a previous run but not reconverted yet).
    if (node->GetDirty(plMaxNode::kAllDirty))
        fDirty = true;

    for (int i = 0; i < node->NumberOfChildren(); ++i)
    {
        plMaxNode *childNode = (plMaxNode*)node->GetChildNode(i);
        IAddNodeRecur(childNode);
    }
}

void SceneWatcher::INotify(void *param, NotifyInfo *info)
{
    SceneWatcher *inst = (SceneWatcher*)param;

    int code = info->intcode;

    // New node was added to the scene, add it to our refs
    if (code == NOTIFY_NODE_CREATED)
    {
        plMaxNode *node = (plMaxNode*)info->callParam;

        // Add a ref to the node and set it to dirty
        inst->IAddRef(node);
        node->SetDirty(plMaxNodeBase::kAllDirty, true);
        inst->ISetDirty();
    }
}

void SceneWatcher::ISetDirty()
{
    fDirty = true;
}

#include "../MaxComponent/plMiscComponents.h"

#include "../MaxExport/plExportErrorMsg.h"
#include "../MaxExport/plExportProgressBar.h"
#include "../MaxComponent/plResponderComponent.h"   // Just need the CID

void SceneWatcher::IGetLogicDependents(plMaxNode *node, NodeSet& nodes)
{
    int attached = node->NumAttachedComponents();
    for (int i = 0; i < attached; i++)
    {
        plComponentBase *comp = node->GetAttachedComponent(i);
/*
        if (comp->ClassID() == ACTIVATOR_CID)
        {
            plMaxNodeBase *activatorNode = comp->GetINode();
            int numResponders = activatorNode->NumAttachedComponents(true);
            for (int i = 0; i < numResponders; i++)
            {
                plComponentBase *responderComp = activatorNode->GetAttachedComponent(i, true);
                if (responderComp->ClassID() == RESPONDER_CID)
                {
                    for (int j = 0; j < responderComp->NumTargets(); j++)
                    {
                        plMaxNode *targ = (plMaxNode*)responderComp->GetTarget(j);
                        if (targ && nodes.find(targ) == nodes.end())
                        {
                            nodes.insert(targ);
                            IGetLogicDependents(targ, nodes);
                        }
                    }
                }
            }
        }
        else
*/
        if (comp->ClassID() == RESPONDER_CID)
        {
            int activatorCnt = ResponderGetActivatorCount(comp);
            for (int i = 0; i < activatorCnt; i++)
            {
                plComponentBase *activator = ResponderGetActivator(comp, i);

                for (int j = 0; j < activator->NumTargets(); j++)
                {
                    plMaxNode *targ = (plMaxNode*)activator->GetTarget(j);
                    if (targ && nodes.find(targ) == nodes.end())
                    {
                        nodes.insert(targ);
                        IGetLogicDependents(targ, nodes);
                    }
                }
            }
        }
    }
}

void SceneWatcher::IGetDependents(plMaxNode *node, NodeSet& nodes)
{
    NodeSet dependents;

    if (node->IsComponent())
    {
        plComponentBase *comp = node->ConvertToComponent();

        if (comp->ClassID() == ROOM_CID || comp->ClassID() == PAGEINFO_CID)
            return;

        for (int i = 0; i < comp->NumTargets(); i++)
        {
            plMaxNode *targ = (plMaxNode*)comp->GetTarget(i);
            if (targ)
            {
                dependents.insert(targ);
                IGetLogicDependents(targ, dependents);
            }
        }
    }
    else
    {
        dependents.insert(node);

        IGetLogicDependents(node, dependents);
    }

//  Bug in VC++?
//  nodes.insert(dependents.begin(), dependents.end());
    for (NodeSet::iterator i = dependents.begin(); i != dependents.end(); i++)
        nodes.insert(*i);
}