CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plAnimEventComponent.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 "HeadSpin.h"
#include "plAnimEventComponent.h"
#include "plComponentReg.h"
#include "resource.h"
#include "../MaxMain/plMaxNode.h"

#include "plAnimComponent.h"
#include "plNotetrackAnim.h"

#include "plAnimCompProc.h"
#include "plPickNode.h"

#include "../plModifier/plAnimEventModifier.h"
#include "../plMessage/plAnimCmdMsg.h"
#include "hsResMgr.h"
#include "../pnMessage/plRefMsg.h"

void DummyCodeIncludeFuncAnimDetector() {}

CLASS_DESC(plAnimEventComponent, gAnimEventDesc, "Anim Event", "AnimEvent", COMP_TYPE_DETECTOR, ANIMEVENT_CID)


class plAnimEventProc : public plAnimCompProc
{
protected:
	virtual void IPickComponent(IParamBlock2* pb);
	virtual void ILoadUser(HWND hWnd, IParamBlock2* pb);
	virtual bool IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID);

public:
	plAnimEventProc();
};
static plAnimEventProc gAnimEventProc;


enum
{
	kAnimComp,
	kAnimNode,
	kAnimEvent_DEAD,
	kAnimName_DEAD,

	kAnimBegin,
	kAnimEnd,
	kAnimMarkers,
};

enum
{
	kAnimEventBegin,
	kAnimEventEnd,
	kAnimEventMarker,
};

ParamBlockDesc2 gAnimEventBlock
(
	plComponent::kBlkComp, _T("animEvent"), 0, &gAnimEventDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_DETECTOR_ANIM, IDS_COMP_DETECTOR_ANIM, 0, 0, &gAnimEventProc,

	kAnimComp,	_T("animComp"),	TYPE_INODE,	0, 0,
		end,

	kAnimNode,	_T("animNode"),	TYPE_INODE,	0, 0,
		end,

	kAnimBegin,	_T("animBegin"),	TYPE_BOOL,	0, 0,
		end,
	kAnimEnd,	_T("animEnd"),		TYPE_BOOL,	0, 0,
		end,
	kAnimMarkers,	_T("animMarkers"),	TYPE_STRING_TAB, 0,		0, 0,
		end,

	end
);


plAnimEventComponent::plAnimEventComponent() : fCanExport(false)
{
	fClassDesc = &gAnimEventDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plAnimEventComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	plComponentBase* animComp;
	plMaxNode* animNode;
	if (!gAnimEventProc.GetCompAndNode(fCompPB, animComp, animNode))
	{
		pErrMsg->Set(true,
					"Anim Event Component",
					"Component %s does not have a valid anim component and node selected.\n"
					"It will not be exported.",
					GetINode()->GetName()).Show();
		pErrMsg->Set(false);
		fCanExport = false;
	}
	else
		fCanExport = true;

	return plActivatorBaseComponent::SetupProperties(node, pErrMsg);
}

hsBool plAnimEventComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	if (!fCanExport)
		return false;

	plAnimEventModifier* mod = TRACKED_NEW plAnimEventModifier;
	plKey modKey = node->AddModifier(mod, IGetUniqueName(node));

	fLogicModKeys[node] = modKey;

	return true;
}

plEventCallbackMsg* CreateCallbackMsg(plAnimCmdMsg* animMsg, plKey modKey)
{
	plEventCallbackMsg *eventMsg = TRACKED_NEW plEventCallbackMsg;
	eventMsg->AddReceiver(modKey);
	eventMsg->fRepeats = -1;

	animMsg->AddCallback(eventMsg);
	hsRefCnt_SafeUnRef(eventMsg);	// AddCallback adds it's own ref, so remove ours (the default of 1)

	return eventMsg;
}

hsBool plAnimEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	if (!fCanExport)
		return false;

	plKey modKey = fLogicModKeys[node];
	plAnimEventModifier* mod = plAnimEventModifier::ConvertNoRef(modKey->GetObjectPtr());

	plAnimComponentBase* animComp;
	plMaxNode* animNode;
	gAnimEventProc.GetCompAndNode(fCompPB, (plComponentBase*&)animComp, animNode);

	//
	// Create and setup the callback message
	//
	plKey animKey = animComp->GetModKey(animNode);
	const char* animName = animComp->GetAnimName();

	plAnimCmdMsg *animMsg = TRACKED_NEW plAnimCmdMsg;
	animMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
	animMsg->SetSender(modKey);
	animMsg->SetAnimName(animName);
	animMsg->AddReceiver(animKey);

	if (fCompPB->GetInt(kAnimBegin))
	{
		plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
		eventMsg->fEvent = kBegin;
	}
	if (fCompPB->GetInt(kAnimEnd))
	{
		plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
		eventMsg->fEvent = kEnd;
	}
	if (fCompPB->Count(kAnimMarkers) > 0)
	{
		plNotetrackAnim anim(animComp, nil);
		plAnimInfo info = anim.GetAnimInfo(animName);

		int numMarkers = fCompPB->Count(kAnimMarkers);
		for (int i = 0; i < numMarkers; i++)
		{
			const char* marker = fCompPB->GetStr(kAnimMarkers, 0, i);
			float time = info.GetMarkerTime(marker);

			plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
			eventMsg->fEvent = kTime;
			eventMsg->fEventTime = time;
		}
	}

	mod->SetCallback(animMsg);
	
	hsTArray<plKey> receivers;
	IGetReceivers(node, receivers);
	mod->SetReceivers(receivers);

	return true;
}


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


plAnimEventProc::plAnimEventProc()
{
	fCompButtonID	= IDC_ANIM_BUTTON;
	fCompParamID	= kAnimComp;
	fNodeButtonID	= IDC_NODE_BUTTON;
	fNodeParamID	= kAnimNode;
}

void plAnimEventProc::IPickComponent(IParamBlock2* pb)
{
	std::vector<Class_ID> cids;
	cids.push_back(ANIM_COMP_CID);
	cids.push_back(ANIM_GROUP_COMP_CID);

	plPick::Node(pb, kAnimComp, &cids, true, false);
}

static int ListBox_AddStringData(HWND hList, const char* text, int data)
{
	int idx = ListBox_AddString(hList, text);
	ListBox_SetItemData(hList, idx, data);
	return idx;
}

static bool IsMarkerSelected(IParamBlock2* pb, int paramID, const char* marker, bool remove=false)
{
	int numMarkers = pb->Count(paramID);
	for (int i = 0; i < numMarkers; i++)
	{
		if (hsStrEQ(marker, pb->GetStr(paramID, 0, i)))
		{
			if (remove)
				pb->Delete(paramID, i, 1);
			return true;
		}
	}

	return false;
}

//
// Remove markers we had saved that aren't in the object's notetrack any more
//
static void RemoveDeadMarkers(IParamBlock2* pb, int paramID, plAnimInfo& info)
{
	int numMarkers = pb->Count(paramID);
	for (int i = numMarkers-1; i >= 0; i--)
	{
		float time = info.GetMarkerTime(pb->GetStr(paramID, 0, i));
		if (time == -1)
		{
			pb->Delete(paramID, i, 1);
		}
	}
}

void plAnimEventProc::ILoadUser(HWND hWnd, IParamBlock2* pb)
{
	HWND hList = GetDlgItem(hWnd, IDC_EVENT_LIST);
	ListBox_ResetContent(hList);

	plAnimComponentBase* comp;
	plMaxNode* node;

	//
	// If we don't have a valid comp and node, we should be disabled
	//
	if (!GetCompAndNode(pb, (plComponentBase*&)comp, node))
	{
		EnableWindow(hList, FALSE);
		return;
	}
	else
		EnableWindow(hList, TRUE);

	//
	// Load the events
	//
	int idx;

	idx = ListBox_AddStringData(hList, "(Begin)", kAnimEventBegin);
	if (pb->GetInt(kAnimBegin))
		ListBox_SetSel(hList, TRUE, idx);

	idx = ListBox_AddStringData(hList, "(End)", kAnimEventEnd);
	if (pb->GetInt(kAnimEnd))
		ListBox_SetSel(hList, TRUE, idx);

	if (comp)
	{
		// Get the shared animations for all the nodes this component is applied to
		plNotetrackAnim anim(comp, nil);
		plAnimInfo info = anim.GetAnimInfo(comp->GetAnimName());

		RemoveDeadMarkers(pb, kAnimMarkers, info);

		// Get all the markers in this animation
		while (const char* marker = info.GetNextMarkerName())
		{
			idx = ListBox_AddStringData(hList, marker, kAnimEventMarker);

			if (IsMarkerSelected(pb, kAnimMarkers, marker))
				ListBox_SetSel(hList, TRUE, idx);
		}
	}
}

bool plAnimEventProc::IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID)
{
	if (cmd == LBN_SELCHANGE && resID == IDC_EVENT_LIST)
	{
		HWND hList = GetDlgItem(hWnd, IDC_EVENT_LIST);
		int idx = ListBox_GetCurSel(hList);
		BOOL selected = ListBox_GetSel(hList, idx);
		int eventType = ListBox_GetItemData(hList, idx);

		if (eventType == kAnimEventBegin)
			pb->SetValue(kAnimBegin, 0, selected);
		else if (eventType == kAnimEventEnd)
			pb->SetValue(kAnimEnd, 0, selected);
		else if (eventType == kAnimEventMarker)
		{
			char buf[256];
			ListBox_GetText(hList, idx, buf);
			if (selected)
			{
				if (!IsMarkerSelected(pb, kAnimMarkers, buf))
				{
					TCHAR* name = buf;
					pb->Append(kAnimMarkers, 1, &name);
				}
			}
			else
				IsMarkerSelected(pb, kAnimMarkers, buf, true);
		}

		return true;
	}

	return false;
}


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


CLASS_DESC(plMtlEventComponent, gMtlEventDesc, "Mtl Event", "MtlEvent", COMP_TYPE_DETECTOR, MTLEVENT_CID)

class plMtlEventProc : public plMtlAnimProc
{
public:
	plMtlEventProc();

protected:
	virtual void ILoadUser(HWND hWnd, IParamBlock2* pb);
	virtual bool IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID);
};
static plMtlEventProc gMtlEventProc;

enum
{
	kMtlMtl,
	kMtlNode,
	kMtlAnim,

	kMtlBegin,
	kMtlEnd,
	kMtlMarkers,
};

ParamBlockDesc2 gMtlEventBlock
(
	plComponent::kBlkComp, _T("mtlEvent"), 0, &gMtlEventDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_DETECTOR_MTL, IDS_COMP_DETECTOR_MTL, 0, 0, &gMtlEventProc,

	kMtlMtl,	_T("mtl"),			TYPE_MTL,			0, 0,
		end,

	kMtlNode,	_T("node"),			TYPE_INODE,			0, 0,
		end,

	kMtlAnim,	_T("anim"),			TYPE_STRING,		0, 0,
		end,

	kMtlBegin,	_T("animBegin"),	TYPE_BOOL,			0, 0,
		end,
	kMtlEnd,	_T("animEnd"),		TYPE_BOOL,			0, 0,
		end,
	kMtlMarkers,_T("markers"),		TYPE_STRING_TAB, 0,	0, 0,
		end,

	end
);


plMtlEventComponent::plMtlEventComponent() : fCanExport(false)
{
	fClassDesc = &gMtlEventDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plMtlEventComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	Mtl* mtl = fCompPB->GetMtl(kMtlMtl);

	if (!mtl)
	{
		pErrMsg->Set(true,
					"Mtl Event Component",
					"Component %s does not have a valid material selected.\n"
					"It will not be exported.",
					GetINode()->GetName()).Show();
		pErrMsg->Set(false);
		fCanExport = false;
	}
	else
		fCanExport = true;

	return plActivatorBaseComponent::SetupProperties(node, pErrMsg);
}

hsBool plMtlEventComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	if (!fCanExport)
		return false;

	plAnimEventModifier* mod = TRACKED_NEW plAnimEventModifier;
	plKey modKey = node->AddModifier(mod, IGetUniqueName(node));

	fLogicModKeys[node] = modKey;

	return true;
}

// KLUDGE - The material animation key getter is here, so we have to include all this crap
#include "plResponderMtl.h"

hsBool plMtlEventComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	if (!fCanExport)
		return false;

	plKey modKey = fLogicModKeys[node];
	plAnimEventModifier* mod = plAnimEventModifier::ConvertNoRef(modKey->GetObjectPtr());

	Mtl* mtl = fCompPB->GetMtl(kMtlMtl);
	plMaxNodeBase* mtlNode = (plMaxNodeBase*)fCompPB->GetINode(kMtlNode);
	const char* mtlAnim = fCompPB->GetStr(kMtlAnim);

	//
	// Create and setup the callback message
	//
	hsTArray<plKey> animKeys;
	GetMatAnimModKey(mtl, mtlNode, mtlAnim, animKeys);

	plAnimCmdMsg *animMsg = TRACKED_NEW plAnimCmdMsg;
	animMsg->SetCmd(plAnimCmdMsg::kAddCallbacks);
	animMsg->SetSender(modKey);
	animMsg->SetAnimName(mtlAnim);
	animMsg->AddReceivers(animKeys);

	if (fCompPB->GetInt(kMtlBegin))
	{
		plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
		eventMsg->fEvent = kBegin;
	}
	if (fCompPB->GetInt(kMtlEnd))
	{
		plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
		eventMsg->fEvent = kEnd;
	}
	if (fCompPB->Count(kMtlMarkers) > 0)
	{
		plNotetrackAnim anim(mtl, nil);
		plAnimInfo info = anim.GetAnimInfo(mtlAnim);

		int numMarkers = fCompPB->Count(kMtlMarkers);
		for (int i = 0; i < numMarkers; i++)
		{
			const char* marker = fCompPB->GetStr(kMtlMarkers, 0, i);
			float time = info.GetMarkerTime(marker);

			plEventCallbackMsg *eventMsg = CreateCallbackMsg(animMsg, modKey);
			eventMsg->fEvent = kTime;
			eventMsg->fEventTime = time;
		}
	}

	mod->SetCallback(animMsg);

	hsTArray<plKey> receivers;
	IGetReceivers(node, receivers);
	mod->SetReceivers(receivers);

	return true;
}


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


plMtlEventProc::plMtlEventProc()
{
	fMtlButtonID		= IDC_MTL_BUTTON;
	fMtlParamID			= kMtlMtl;
	fNodeButtonID		= IDC_NODE_BUTTON;
	fNodeParamID		= kMtlNode;
	fAnimComboID		= IDC_ANIM_COMBO;
	fAnimParamID		= kMtlAnim;
}

void plMtlEventProc::ILoadUser(HWND hWnd, IParamBlock2* pb)
{
	HWND hList = GetDlgItem(hWnd, IDC_EVENT_LIST);
	ListBox_ResetContent(hList);

	//
	// If we don't have a valid material, we should be disabled
	//
	Mtl* mtl = pb->GetMtl(kMtlMtl);
	if (!mtl)
	{
		EnableWindow(hList, FALSE);
		return;
	}
	else
		EnableWindow(hList, TRUE);

	//
	// Load the events
	//
	int idx;

	idx = ListBox_AddStringData(hList, "(Begin)", kAnimEventBegin);
	if (pb->GetInt(kMtlBegin))
		ListBox_SetSel(hList, TRUE, idx);

	idx = ListBox_AddStringData(hList, "(End)", kAnimEventEnd);
	if (pb->GetInt(kMtlEnd))
		ListBox_SetSel(hList, TRUE, idx);

	if (mtl)
	{
		const char* mtlAnim = pb->GetStr(kMtlAnim);

		// Get the shared animations for all the nodes this component is applied to
		plNotetrackAnim anim(mtl, nil);
		plAnimInfo info = anim.GetAnimInfo(mtlAnim);

		RemoveDeadMarkers(pb, kMtlMarkers, info);

		// Get all the markers in this animation
		while (const char* marker = info.GetNextMarkerName())
		{
			idx = ListBox_AddStringData(hList, marker, kAnimEventMarker);

			if (IsMarkerSelected(pb, kMtlMarkers, marker))
				ListBox_SetSel(hList, TRUE, idx);
		}
	}
}

bool plMtlEventProc::IUserCommand(HWND hWnd, IParamBlock2* pb, int cmd, int resID)
{
	if (cmd == LBN_SELCHANGE && resID == IDC_EVENT_LIST)
	{
		HWND hList = GetDlgItem(hWnd, IDC_EVENT_LIST);
		int idx = ListBox_GetCurSel(hList);
		BOOL selected = ListBox_GetSel(hList, idx);
		int eventType = ListBox_GetItemData(hList, idx);

		if (eventType == kAnimEventBegin)
			pb->SetValue(kMtlBegin, 0, selected);
		else if (eventType == kAnimEventEnd)
			pb->SetValue(kMtlEnd, 0, selected);
		else if (eventType == kAnimEventMarker)
		{
			char buf[256];
			ListBox_GetText(hList, idx, buf);
			if (selected)
			{
				if (!IsMarkerSelected(pb, kMtlMarkers, buf))
				{
					TCHAR* name = buf;
					pb->Append(kMtlMarkers, 1, &name);
				}
			}
			else
				IsMarkerSelected(pb, kMtlMarkers, buf, true);
		}

		return true;
	}

	return false;
}