/*==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);
}