/*==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 "max.h"
#include "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"

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

#include "../MaxConvert/hsConverterUtils.h"
#include "../MaxConvert/hsControlConverter.h"
#include "../plInterp/plController.h"
#include "../MaxMain/plMaxNode.h"
#include "../pnKeyedObject/plKey.h"

#include "plgDispatch.h"
#include "../MaxMain/plPluginResManager.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"

// Swivel related
#include "../pfAnimation/plViewFaceModifier.h" // ViewFace Comp

// Line Follow related
#include "../plInterp/plAnimPath.h"
#include "../pfAnimation/plLineFollowMod.h"
#include "../pfAnimation/plFollowMod.h"

#include "../pnMessage/plRefMsg.h"

// Stereizer
#include "../pfAnimation/plStereizer.h"

const Class_ID STEREIZE_COMP_CID(0x15066ec7, 0x64ea7381);
const Class_ID LINEFOLLOW_COMP_CID(0x64ec57f6, 0x292d47f6);
const Class_ID SWIVEL_COMP_CID(0x106a466b, 0x1c1700f7);

void DummyCodeIncludeFuncLineFollow()
{
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//
//	LineFollow Component
//
//

enum	
{
	kFollowModeRadio,
	kPathObjectSel,
	kFollowObjectSel,
	kOffsetActive,
	kOffsetDegrees,
	kOffsetClampActive,
	kOffsetClamp,
	kForceToLine,
	kSpeedClampActive,
	kSpeedClamp
};

// When one of our parameters that is a ref changes, send out the component ref
// changed message.  Normally, messages from component refs are ignored since
// they pass along all the messages of the ref, which generates a lot of false
// converts.
class plLineObjAccessor : public PBAccessor
{
public:
	void Set(PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t)
	{
		if( (id == kFollowObjectSel) || (id == kPathObjectSel) )
		{
			plComponentBase* comp = (plComponentBase*)owner;
			comp->NotifyDependents(FOREVER, PART_ALL, REFMSG_USER_COMP_REF_CHANGED);
		}
	}
};
plLineObjAccessor gLineObjAccessor;


class plLineFollowComponentProc : public ParamMap2UserDlgProc
{
public:
	BOOL DlgProc(TimeValue t, IParamMap2* map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
	{
		switch (msg)
		{
		case WM_INITDIALOG:
			{
					IParamBlock2* pb = map->GetParamBlock();
					map->SetTooltip(kPathObjectSel, TRUE, "Press the button, & select the path source object in one of the Viewports" );
					map->SetTooltip(kFollowObjectSel, TRUE, "Press the button, & select the object to follow in one of the Viewports" );
					map->SetTooltip(kOffsetDegrees, TRUE, "Positive angle to right, negative to left." );
					if( pb->GetInt(kFollowModeRadio) == plLineFollowMod::kFollowObject )
						map->Enable(kFollowObjectSel, TRUE);
					else
						map->Enable(kFollowObjectSel, FALSE);
			}
			return true;

//////////////////
		case WM_COMMAND:
			{
				if( (LOWORD(wParam) == IDC_RADIO_LISTENER)
					|| (LOWORD(wParam) == IDC_RADIO_CAMERA)
					|| (LOWORD(wParam) == IDC_RADIO_OBJECT) )
				{
					IParamBlock2* pb = map->GetParamBlock();
					if( pb->GetInt(kFollowModeRadio) == plLineFollowMod::kFollowObject )
						map->Enable(kFollowObjectSel, TRUE);
					else
						map->Enable(kFollowObjectSel, FALSE);
					
					return true;
				}
			}
			
		}

		return false;
	}
	void DeleteThis() {}
};
static plLineFollowComponentProc gLineFollowProc;


//Class that accesses the paramblock below.
class plLineFollowComponent : public plComponent
{
private:
	hsBool			fValid;

	plLineFollowMod*	fLineMod;

	hsBool		IMakeLineMod(plMaxNode* pNode, plErrorMsg* pErrMsg);

public:
	plLineFollowComponent();

	hsBool SetupProperties(plMaxNode* pNode, plErrorMsg* pErrMsg);
	hsBool PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg);
	hsBool Convert(plMaxNode* node, plErrorMsg* pErrMsg);

	plLineFollowMod*	GetLineMod(plErrorMsg* pErrMsg);
};



CLASS_DESC(plLineFollowComponent, gLineFollowDesc, "LineFollow",  "LineFollow", COMP_TYPE_GRAPHICS, LINEFOLLOW_COMP_CID)



ParamBlockDesc2 gLineFollowBk
(
	plComponent::kBlkComp, _T("LineFollow"), 0, &gLineFollowDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_LINEFOLLOW, IDS_COMP_LINEFOLLOWS,  0, 0, &gLineFollowProc,

	kFollowModeRadio, _T("FollowMode"),		TYPE_INT, 		0, 0,
		p_ui,		TYPE_RADIO, 3,	IDC_RADIO_LISTENER,					IDC_RADIO_CAMERA,				IDC_RADIO_OBJECT,	
		p_vals,						plLineFollowMod::kFollowListener,	plLineFollowMod::kFollowCamera,	plLineFollowMod::kFollowObject,		
		p_default, plLineFollowMod::kFollowListener,
		end,

	kPathObjectSel, _T("PathObjectChoice"),	TYPE_INODE,		0, 0,
		p_ui,	TYPE_PICKNODEBUTTON, IDC_COMP_LINE_CHOOSE_PATH,
		p_prompt, IDS_COMP_LINE_CHOSE_PATH,
		p_accessor, &gLineObjAccessor,
		end,

	kFollowObjectSel, _T("FollowObjectChoice"),	TYPE_INODE,		0, 0,
		p_ui,	TYPE_PICKNODEBUTTON, IDC_COMP_LINE_CHOOSE_OBJECT,
		p_prompt, IDS_COMP_LINE_CHOSE_OBJECT,
		p_accessor, &gLineObjAccessor,
		end,

	kOffsetActive,  _T("OffsetActive"), TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_LINE_OFFSETACTIVE,
		p_enable_ctrls,		4, kOffsetDegrees, kOffsetClampActive, kOffsetClamp, kForceToLine,
		end,

	kOffsetDegrees, _T("OffsetDegrees"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, -85.0, 85.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_FLOAT,	
		IDC_COMP_LINE_OFFSETDEGREES, IDC_COMP_LINE_OFFSETDEGREES_SPIN, 1.0,
		end,	
	
	kOffsetClampActive,  _T("OffsetClampActive"), TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_LINE_OFFSETCLAMPACTIVE,
		p_enable_ctrls,		1, kOffsetClamp,
		end,

	kOffsetClamp, _T("OffsetClamp"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 1000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_LINE_OFFSETCLAMP, IDC_COMP_LINE_OFFSETCLAMP_SPIN, 1.0,
		end,	
	
	kForceToLine,  _T("ForceToLine"), TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_LINE_FORCETOLINE,
		end,

	kSpeedClampActive,  _T("SpeedClampActive"), TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_LINE_SPEEDCLAMPACTIVE,
		p_enable_ctrls,		1, kSpeedClamp,
		end,

	kSpeedClamp, _T("SpeedClamp"), TYPE_FLOAT, 	0, 0,	
		p_default, 30.0,
		p_range, 3.0, 1000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_LINE_SPEEDCLAMP, IDC_COMP_LINE_SPEEDCLAMP_SPIN, 1.0,
		end,	
	
	end

);

plLineFollowComponent::plLineFollowComponent()
:	fValid(false),
	fLineMod(nil)
{
	fClassDesc = &gLineFollowDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plLineFollowComponent::IMakeLineMod(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
	plLineFollowMod::FollowMode mode = plLineFollowMod::FollowMode(fCompPB->GetInt(kFollowModeRadio));

	plLineFollowMod* lineMod = TRACKED_NEW plLineFollowMod;
	hsgResMgr::ResMgr()->NewKey(IGetUniqueName(pNode), lineMod, pNode->GetLocation());

	if( plLineFollowMod::kFollowObject == mode )
	{
		if(fCompPB->GetINode(kFollowObjectSel) != NULL)


		{
			plMaxNode* targNode = (plMaxNode*)fCompPB->GetINode(kFollowObjectSel);
			//plMaxNodeData* pMD = targNode->GetMaxNodeData();
			if( targNode->CanConvert() )
			{
				plSceneObject* targObj = targNode->GetSceneObject();
				if( targObj )
				{
					plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(lineMod->GetKey(), plRefMsg::kOnCreate, 0, plLineFollowMod::kRefObject);
					hsgResMgr::ResMgr()->AddViaNotify(targObj->GetKey(), refMsg, plRefFlags::kPassiveRef);

					lineMod->SetFollowMode(plLineFollowMod::kFollowObject);
				}
			}
		}
	}
	else
	{
		lineMod->SetFollowMode(mode);
	}

	plMaxNode* pathNode = (plMaxNode*)fCompPB->GetINode(kPathObjectSel);
	if(!pathNode)
	{
		pErrMsg->Set(true, "Path Node Failure", "Path Node %s was set to be Ignored or empty. Path Component ignored.", ((INode*)pathNode)->GetName()).Show();
		pErrMsg->Set(false);
		return false;
	}
	//hsAssert(pathNode, "If valid is true, this must be set");
	Control* maxTm = pathNode->GetTMController();

	plCompoundController* tmc = hsControlConverter::Instance().MakeTransformController(maxTm, pathNode);

	Matrix3 w2p(true);
	Matrix3 l2w = pathNode->GetNodeTM(TimeValue(0));
	if( !pathNode->GetParentNode()->IsRootNode() )
		w2p = Inverse(pathNode->GetParentNode()->GetNodeTM(TimeValue(0)));
	hsMatrix44 loc2Par = pathNode->Matrix3ToMatrix44(l2w * w2p);

	gemAffineParts ap;
	decomp_affine(loc2Par.fMap, &ap); 
	hsAffineParts initParts;
	AP_SET(initParts, ap);

	plAnimPath* animPath = TRACKED_NEW plAnimPath;
	animPath->SetController(tmc);
	animPath->InitParts(initParts);

	lineMod->SetPath(animPath);

	if( !pathNode->GetParentNode()->IsRootNode() )
	{
		plMaxNode* parNode = (plMaxNode*)pathNode->GetParentNode();
		plSceneObject* parObj = parNode->GetSceneObject();
		if( parObj )
		{
			plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(lineMod->GetKey(), plRefMsg::kOnCreate, 0, plLineFollowMod::kRefParent);
			hsgResMgr::ResMgr()->AddViaNotify(parObj->GetKey(), refMsg, plRefFlags::kPassiveRef);
		}
	}

	if( fCompPB->GetInt(kOffsetActive) )
	{
		lineMod->SetOffsetDegrees(fCompPB->GetFloat(kOffsetDegrees));
		
		if( fCompPB->GetInt(kOffsetClampActive) )
		{
			lineMod->SetOffsetClamp(fCompPB->GetFloat(kOffsetClamp));
		}

		lineMod->SetForceToLine(fCompPB->GetInt(kForceToLine));
	}

	if( fCompPB->GetInt(kSpeedClampActive) )
	{
		lineMod->SetSpeedClamp(fCompPB->GetFloat(kSpeedClamp));
	}

	fLineMod = lineMod;

	return true;
}

plLineFollowMod* plLineFollowComponent::GetLineMod(plErrorMsg* pErrMsg)
{
	if( !fValid )
		return nil;
	if( !fLineMod )
	{
		int i;
		for( i = 0; i < NumTargets(); i++ )
		{
			plMaxNode* targ = (plMaxNode*)GetTarget(i);
			IMakeLineMod(targ, pErrMsg);
			if( fLineMod )
				break;
		}
	}
	return fLineMod;
}

hsBool plLineFollowComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	if( !fValid )
		return true;

	if( !fLineMod )
	{
		if( !IMakeLineMod(node, pErrMsg) )
		{
			fValid = false;
			return true;
		}
	}

	node->AddModifier(fLineMod, IGetUniqueName(node));

	return true;
}

hsBool plLineFollowComponent::SetupProperties(plMaxNode* pNode,  plErrorMsg* pErrMsg)
{
	fValid = false;
	fLineMod = nil;

	if( !fCompPB->GetINode(kPathObjectSel) )
	{
		return true;
	}
	plMaxNode* pathNode = (plMaxNode*)fCompPB->GetINode(kPathObjectSel);
	if( !pathNode )
	{
		return true;
	}
	if( !pathNode->IsTMAnimated() )
	{
		return true;
	}
	pathNode->SetCanConvert(false);

	if( plLineFollowMod::kFollowObject == fCompPB->GetInt(kFollowModeRadio) )
	{
		if( !fCompPB->GetINode(kFollowObjectSel) )
		{
			return true;
		}
	}
	fValid = true;
	pNode->SetForceLocal(true);
	pNode->SetMovable(true);
	return true;
}

hsBool plLineFollowComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
	if( !fValid )
		return true;
	fValid = false;

	if( plLineFollowMod::kFollowObject == fCompPB->GetInt(kFollowModeRadio) )
	{
		plMaxNode* followNode = (plMaxNode*)fCompPB->GetINode(kFollowObjectSel);
		if( !followNode->CanConvert() )
		{
			return true;
		}
	}
	plMaxNode* pathNode = (plMaxNode*)fCompPB->GetINode(kPathObjectSel);
	if( !pathNode->GetParentNode()->IsRootNode() )
	{
		if( !((plMaxNode*)pathNode->GetParentNode())->CanConvert() )
		{
			return true;
		}
	}
	fValid = true;


	return true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// The stereizer component is sort of related to LineFollow. Really.

class plStereizeComp : public plComponent
{
public:
	enum
	{
		kLeft,
		kAmbientDist,
		kTransition,
		kSepAngle,
		kMaxDist,
		kMinDist
	};

	plLineFollowMod*	ISetMaster(plStereizer* stereo, plMaxNode* node, plErrorMsg* pErrMsg);

public:
	plStereizeComp();
	void DeleteThis() { delete this; }

	// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
	// of properties on the MaxNode, as it's still indeterminant.
	virtual hsBool SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg);
	virtual hsBool PreConvert(plMaxNode* node, plErrorMsg* pErrMsg);
	virtual hsBool Convert(plMaxNode* node, plErrorMsg* pErrMsg);

	hsBool	Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg);

};



CLASS_DESC(plStereizeComp, gStereizeDesc, "Stereo-ize",  "Stereize", COMP_TYPE_AUDIO, STEREIZE_COMP_CID)

ParamBlockDesc2 gStereizeBk
(	
	plComponent::kBlkComp, _T("Stereize"), 0, &gStereizeDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_STEREIZE, IDS_COMP_STEREIZE, 0, 0, NULL,

	plStereizeComp::kLeft,	_T("Left"),	TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_STEREIZE_LEFT,
		end,

	plStereizeComp::kAmbientDist, _T("AmbientDist"), TYPE_FLOAT, 	0, 0,	
		p_default, 50.0,
		p_range, 0.0, 1000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_STEREIZE_AMB, IDC_COMP_STEREIZE_AMB_SPIN, 1.0,
		end,	

	plStereizeComp::kTransition, _T("Transition"), TYPE_FLOAT, 	0, 0,	
		p_default, 25.0,
		p_range, 1.0, 500.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_STEREIZE_TRANS, IDC_COMP_STEREIZE_TRANS_SPIN, 1.0,
		end,	

	plStereizeComp::kSepAngle, _T("SepAngle"), TYPE_FLOAT, 	0, 0,	
		p_default, 30.0,
		p_range, 1.0, 80.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_STEREIZE_ANG, IDC_COMP_STEREIZE_ANG_SPIN, 1.0,
		end,	

	plStereizeComp::kMaxDist, _T("MaxDist"), TYPE_FLOAT, 	0, 0,	
		p_default, 100.0,
		p_range, 1.0, 1000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_STEREIZE_MAXDIST, IDC_COMP_STEREIZE_MAXDIST_SPIN, 1.0,
		end,	

	plStereizeComp::kMinDist, _T("MinDist"), TYPE_FLOAT, 	0, 0,	
		p_default, 5.0,
		p_range, 1.0, 50.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_STEREIZE_MINDIST, IDC_COMP_STEREIZE_MINDIST_SPIN, 1.0,
		end,	

	end
);

plStereizeComp::plStereizeComp()
{
	fClassDesc = &gStereizeDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plStereizeComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	node->SetForceLocal(true);
	if( !node->GetParentNode()->IsRootNode() )
		((plMaxNode*)node->GetParentNode())->SetForceLocal(true);

	return true;
}

hsBool plStereizeComp::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	return true;
}

hsBool plStereizeComp::Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg)
{
	pErrMsg->Set(true, node->GetName(), msg).CheckAndAsk();
	pErrMsg->Set(false);
	return true;
}

hsBool plStereizeComp::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	plStereizer* stereo = TRACKED_NEW plStereizer;

	stereo->SetAmbientDist(fCompPB->GetFloat(kAmbientDist));
	stereo->SetTransition(fCompPB->GetFloat(kTransition));

	hsScalar ang = fCompPB->GetFloat(kSepAngle);
	if( ang > 80.f )
		ang = 80.f;
	stereo->SetSepAngle(hsScalarDegToRad(ang));

	stereo->SetMaxSepDist(fCompPB->GetFloat(kMaxDist));
	stereo->SetMinSepDist(fCompPB->GetFloat(kMinDist));

	stereo->SetParentInitPos(node->GetLocalToParent44().GetTranslate());

	stereo->SetAsLeftChannel(fCompPB->GetInt(kLeft));

	node->AddModifier(stereo, IGetUniqueName(node));

	// Do this after AddModifier, cuz that's when stereo gets a plKey.
	ISetMaster(stereo, node, pErrMsg);

	return true;
}

plLineFollowMod* plStereizeComp::ISetMaster(plStereizer* stereo, plMaxNode* node, plErrorMsg* pErrMsg)
{
	int numComp = node->NumAttachedComponents(false);

	int i;
	for( i = 0; i < numComp; i++ )
	{
		plComponentBase *comp = node->GetAttachedComponent(i);
		if( comp && (comp->ClassID() == LINEFOLLOW_COMP_CID) )
		{
			plLineFollowComponent* lineComp = (plLineFollowComponent*)comp;
			plLineFollowMod* lineMod = lineComp->GetLineMod(pErrMsg);
			if( lineMod )
			{
				lineMod->AddStereizer(stereo->GetKey());
				return lineMod;
			}
		}
	}
	return nil;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// The swivel component is also sort of related to LineFollow. And stereizer. Really.

class plSwivelComp : public plComponent
{
public:
	enum
	{
		kFaceTypeRadio,
		kFaceObjectSel,
		kPivotY,
		kOffsetActive,
		kOffsetX,
		kOffsetY,
		kOffsetZ,
		kOffsetLocal
	};
	enum
	{
		kFaceCamera,
		kFaceListener,
		kFacePlayer,
		kFaceObject
	};

public:
	plSwivelComp();
	void DeleteThis() { delete this; }

	// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
	// of properties on the MaxNode, as it's still indeterminant.
	virtual hsBool SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg);
	virtual hsBool PreConvert(plMaxNode* node, plErrorMsg* pErrMsg);
	virtual hsBool Convert(plMaxNode* node, plErrorMsg* pErrMsg);

	hsBool	Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg);

};


class plSwivelComponentProc : public ParamMap2UserDlgProc
{
public:
	BOOL DlgProc(TimeValue t, IParamMap2* map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
	{
		switch (msg)
		{
		case WM_INITDIALOG:
			{
					IParamBlock2* pb = map->GetParamBlock();
					if( pb->GetInt(plSwivelComp::kFaceTypeRadio) == plSwivelComp::kFaceObject )
						map->Enable(plSwivelComp::kFaceObjectSel, TRUE);
					else
						map->Enable(plSwivelComp::kFaceObjectSel, FALSE);
			}
			return true;

//////////////////
		case WM_COMMAND:
			{
				if( (LOWORD(wParam) == IDC_RADIO_LISTENER)
					|| (LOWORD(wParam) == IDC_RADIO_PLAYER)
					|| (LOWORD(wParam) == IDC_RADIO_CAMERA)
					|| (LOWORD(wParam) == IDC_RADIO_OBJECT) )
				{
					IParamBlock2* pb = map->GetParamBlock();
					if( pb->GetInt(plSwivelComp::kFaceTypeRadio) == plSwivelComp::kFaceObject )
						map->Enable(plSwivelComp::kFaceObjectSel, TRUE);
					else
						map->Enable(plSwivelComp::kFaceObjectSel, FALSE);
					
					return true;
				}
			}
			
		}

		return false;
	}
	void DeleteThis() {}
};
static plSwivelComponentProc gSwivelProc;


CLASS_DESC(plSwivelComp, gSwivelDesc, "Swivel",  "Swivel", COMP_TYPE_GRAPHICS, SWIVEL_COMP_CID)

ParamBlockDesc2 gSwivelBk
(	
	plComponent::kBlkComp, _T("Swivel"), 0, &gSwivelDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_SWIVEL, IDS_COMP_SWIVEL, 0, 0, &gSwivelProc,

	plSwivelComp::kFaceTypeRadio, _T("FaceType"),		TYPE_INT, 		0, 0,
		p_ui,		TYPE_RADIO, 4,	IDC_RADIO_CAMERA, IDC_RADIO_LISTENER, IDC_RADIO_PLAYER, IDC_RADIO_OBJECT,	
		p_vals,						plSwivelComp::kFaceCamera, plSwivelComp::kFaceListener, plSwivelComp::kFacePlayer, plSwivelComp::kFaceObject,
		p_default, plSwivelComp::kFacePlayer,
		end,

	plSwivelComp::kFaceObjectSel, _T("FaceObjectChoice"),	TYPE_INODE,		0, 0,
		p_ui,	TYPE_PICKNODEBUTTON, IDC_COMP_CHOOSE_OBJECT,
		p_prompt, IDS_COMP_CHOOSE_OBJECT,
		end,

	plSwivelComp::kPivotY,  _T("PivotY"), TYPE_BOOL, 		0, 0,
		p_default,	TRUE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_PIVOTY,
		end,

	plSwivelComp::kOffsetActive,  _T("OffsetActive"), TYPE_BOOL, 		0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_OFFSETACTIVE,
		p_enable_ctrls,		4, plSwivelComp::kOffsetX, plSwivelComp::kOffsetY, plSwivelComp::kOffsetZ, plSwivelComp::kOffsetLocal,
		end,

	plSwivelComp::kOffsetX, _T("X"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 100.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_OFFSETX, IDC_COMP_OFFSETX_SPIN, 1.0,
		end,	

	plSwivelComp::kOffsetY, _T("Y"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 100.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_OFFSETY, IDC_COMP_OFFSETY_SPIN, 1.0,
		end,	

	plSwivelComp::kOffsetZ, _T("Z"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 100.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_OFFSETZ, IDC_COMP_OFFSETZ_SPIN, 1.0,
		end,	

	plSwivelComp::kOffsetLocal,  _T("OffsetLocal"), TYPE_BOOL, 		0, 0,
		p_default,	TRUE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_OFFSETLOCAL,
		end,

	end
);

plSwivelComp::plSwivelComp()
{
	fClassDesc = &gSwivelDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plSwivelComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	node->SetForceLocal(true);
	node->SetMovable(true);

	return true;
}

hsBool plSwivelComp::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	return true;
}

hsBool plSwivelComp::Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg)
{
	pErrMsg->Set(true, node->GetName(), msg).CheckAndAsk();
	pErrMsg->Set(false);
	return true;
}

hsBool plSwivelComp::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
	plViewFaceModifier* pMod = TRACKED_NEW plViewFaceModifier;
	pMod->SetOrigTransform(node->GetLocalToParent44(), node->GetParentToLocal44());
	node->AddModifier(pMod, IGetUniqueName(node));

	if( fCompPB->GetInt(kPivotY) )
		pMod->SetFlag(plViewFaceModifier::kPivotY);
	else
		pMod->SetFlag(plViewFaceModifier::kPivotFace);

	switch( fCompPB->GetInt(kFaceTypeRadio) )
	{
	case kFaceCamera:
		pMod->SetFollowMode(plViewFaceModifier::kFollowCamera);
		break;

	case kFaceListener:
		pMod->SetFollowMode(plViewFaceModifier::kFollowListener);
		break;

	case kFacePlayer:
		pMod->SetFollowMode(plViewFaceModifier::kFollowPlayer);
		break;

	case kFaceObject:
		{
			plMaxNode* targNode = (plMaxNode*)fCompPB->GetINode(kFaceObjectSel);
			if( targNode && targNode->CanConvert() )
			{
				pMod->SetFollowMode(plViewFaceModifier::kFollowObject, targNode->GetKey());
			}
			else
			{
				pErrMsg->Set(true, node->GetName(), "Swivel to look at component %s has no Plasma object to look at.", GetINode()->GetName()).Show();
				pErrMsg->Set(false);
				pMod->SetFollowMode(plViewFaceModifier::kFollowCamera);
			}
		}
		break;

	}

	pMod->SetOffsetActive(fCompPB->GetInt(kOffsetActive));
	if( fCompPB->GetInt(kOffsetActive) )
	{
		hsVector3 off(fCompPB->GetFloat(kOffsetX), fCompPB->GetFloat(kOffsetY), fCompPB->GetFloat(kOffsetZ));
		pMod->SetOffset(off, fCompPB->GetInt(kOffsetLocal));
	}

	return true;
}