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

#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plSimulationInterface.h"
#include "../pnKeyedObject/hsKeyedObject.h"
#include "../pnKeyedObject/plKey.h"

#include "../plPhysical/plCollisionDetector.h"	// MM
#include "../plModifier/plLogicModifier.h"
#include "../../NucleusLib/pnModifier/plConditionalObject.h"
#include "../plPhysical/plPickingDetector.h"
#include "../pfConditional/plActivatorConditionalObject.h"
#include "../pfConditional/plFacingConditionalObject.h"
#include "../pfConditional/plObjectInBoxConditionalObject.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../pnMessage/plNotifyMsg.h"
#include "../pnMessage/plCursorChangeMsg.h"

#include "hsResMgr.h"
#include "../MaxMain/plMaxNode.h"
#include "../MaxConvert/plConvert.h"
#include "../MaxMain/plPhysicalProps.h"
#include "../plPhysical/plSimDefs.h"

#include "plResponderComponent.h"

#include "../MaxMain/plPhysicalProps.h"


void DummyCodeIncludeFuncClickable() {}

CLASS_DESC(plClickableComponent, gClickableDesc, "Clickable",  "Clickable", COMP_TYPE_DETECTOR, CLICKABLE_CID)

enum
{
	kClickableDirectional,
	kClickableDegrees,
	kClickableUseProxy,
	kClickableProxy,
	kClickableUseRegion,
	kClickableProxyRegion,
	kClickableToggle_DEAD,
	kClickableOneShot,
	kClickableBoundsType,
	kClickableEnabled,
	kClickablePhysical,
	kClickableIgnoreProxyRegion,
	kClickableFriction,
};

ParamBlockDesc2 gClickableBlock
(
	plComponent::kBlkComp, _T("clickable"), 0, &gClickableDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_DETECTOR_CLICKABLE, IDS_COMP_DETECTOR_CLICKABLE, 0, 0, NULL,

	kClickableDirectional,		_T("directional"),		TYPE_BOOL,				0, 0,
		p_ui,				TYPE_SINGLECHEKBOX,	IDC_COMP_CLICK_OMNI,
		end,

	kClickableDegrees, _T("degrees"),	TYPE_INT,	P_ANIMATABLE, 0,	
		p_range, 1, 180,
		p_default, 180,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_INT, 
		IDC_COMP_CLICK_DEG,	IDC_COMP_CLICK_DEGSPIN, SPIN_AUTOSCALE,
		end,

	kClickableUseProxy,		_T("useProxy"),		TYPE_BOOL,				0, 0,
		p_ui,				TYPE_SINGLECHEKBOX,	IDC_COMP_CLICK_USEPROXY,
		p_enable_ctrls, 1, kClickableProxy,
		end,
		

	kClickableProxy, _T("proxyPrimitave"),	TYPE_INODE,		0, 0,
		p_ui,	TYPE_PICKNODEBUTTON, IDC_COMP_CLICK_PROXY,
//		p_sclassID,	 GEOMOBJECT_CLASS_ID,
		p_prompt, IDS_COMP_PHYS_CHOSEN_BASE,
		end,

	kClickableProxyRegion, _T("proxyRegion"),	TYPE_INODE,		0, 0,
		p_ui,	TYPE_PICKNODEBUTTON, IDC_COMP_CLICK_PROXYREGION,
//		p_sclassID,	 GEOMOBJECT_CLASS_ID,
		p_prompt, IDS_COMP_PHYS_CHOSEN_BASE,
		end,
	
	kClickableOneShot,		_T("oneshot"),		TYPE_BOOL,				0, 0,
		p_ui,				TYPE_SINGLECHEKBOX,	IDC_ONESHOT,
		end,

	kClickableBoundsType,	_T("BoundingConditions"),		TYPE_INT, 		0, 0,
		p_ui,		TYPE_RADIO, 4, IDC_RADIO_BSPHERE, IDC_RADIO_BBOX, IDC_RADIO_BHULL, IDC_RADIO_PICKSTATE,
		p_vals,						plSimDefs::kSphereBounds,		plSimDefs::kBoxBounds,		plSimDefs::kHullBounds,		plSimDefs::kProxyBounds,
		p_default, plSimDefs::kHullBounds,
		end,

	kClickableEnabled,		_T("enabled"),		TYPE_BOOL,			0, 0,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_ENABLED,
		p_default, TRUE,
		end,

	kClickablePhysical,		_T("physical"),		TYPE_BOOL,				0, 0,
		p_ui,				TYPE_SINGLECHEKBOX,	IDC_COLLIDABLE_CHECK,
		p_default, TRUE,
		end,

	kClickableIgnoreProxyRegion, _T("ignoreProxyRegion"), TYPE_BOOL,	0, 0,
		p_ui,				TYPE_SINGLECHEKBOX,	IDC_IGNORE_REGION_CHECK,
		p_default, FALSE,
		end,

	kClickableFriction, _T("friction"),	TYPE_FLOAT,	0, 0,	
		p_range, 0.0f, FLT_MAX,
		p_default, 0.0f,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT, 
		IDC_COMP_CLICKABLE_FRIC_EDIT1,	IDC_COMP_CLICKABLE_FRIC_SPIN1, SPIN_AUTOSCALE,
		end,
	end
);

plClickableComponent::plClickableComponent()
{
	fClassDesc = &gClickableDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

void plClickableComponent::CollectNonDrawables(INodeTab& nonDrawables)
{
	if( fCompPB->GetInt(kClickableUseProxy) )
	{
		INode* clickNode = fCompPB->GetINode(kClickableProxy);
		if( clickNode )
			nonDrawables.Append(1, &clickNode);
	}
	INode* detectNode = fCompPB->GetINode(kClickableProxyRegion);
	if( detectNode )
		nonDrawables.Append(1, &detectNode);

}

hsBool plClickableComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
	plActivatorBaseComponent::SetupProperties(node, pErrMsg);

	bool physical = (fCompPB->GetInt(kClickablePhysical) != 0);

	//
	// Phys Props for the Clickable itself.
	//
	plMaxNode *clickNode = node;
	if (fCompPB->GetInt(kClickableUseProxy))
	{
		clickNode = (plMaxNode*)fCompPB->GetINode(kClickableProxy);
		if (clickNode)
			clickNode->SetDrawable(false);
		else
			clickNode = node;
	}

	if (clickNode)
	{
		plPhysicalProps *physProps = clickNode->GetPhysicalProps();
		physProps->SetLOSUIItem(true, clickNode, pErrMsg);
		if (physical)
		{
			physProps->SetGroup(plSimDefs::kGroupStatic, clickNode, pErrMsg);
			// only if movable will it have mass (then it will keep track of movements in PhysX)
			if ( clickNode->IsMovable() || clickNode->IsTMAnimatedRecur() )
				physProps->SetMass(1.0, clickNode, pErrMsg);
			physProps->SetFriction(fCompPB->GetFloat(kClickableFriction),clickNode,pErrMsg);
		}
		else
		{
			physProps->SetGroup(plSimDefs::kGroupLOSOnly, clickNode, pErrMsg);
			if(clickNode->IsMovable() || clickNode->IsTMAnimatedRecur())
			{
				physProps->SetMass(1.0, clickNode, pErrMsg);

			}
		}
		physProps->SetBoundsType(fCompPB->GetInt(kClickableBoundsType), clickNode, pErrMsg);
	}

	//
	// Phys Properties for the auto-generated Detector Region...
	//
	plMaxNode* detectNode = (plMaxNode*)fCompPB->GetINode(kClickableProxyRegion);
	if (detectNode)
	{
		plPhysicalProps *physPropsDetector = detectNode->GetPhysicalProps();
//		physPropsDetector->SetAllowLOS(true, detectNode, pErrMsg);
		physPropsDetector->SetProxyNode(detectNode, node, pErrMsg);
		physPropsDetector->SetBoundsType(plSimDefs::kHullBounds, detectNode, pErrMsg);
		// only if movable will it have mass (then it will keep track of movements in PhysX)
		if ( detectNode->IsMovable() || detectNode->IsTMAnimatedRecur() )
			physPropsDetector->SetMass(1.0, detectNode, pErrMsg);

		physPropsDetector->SetGroup(plSimDefs::kGroupDetector, detectNode, pErrMsg );
		physPropsDetector->SetReportGroup(1<<plSimDefs::kGroupAvatar, detectNode, pErrMsg );
	}

	return true;
}

hsBool plClickableComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{

	plMaxNode *clickNode = node;
	if (fCompPB->GetInt(kClickableUseProxy))
	{
		clickNode = (plMaxNode*)fCompPB->GetINode(kClickableProxy);
		if (clickNode)
			clickNode->SetDrawable(false);
		else
			clickNode = node;
	}

	clickNode->SetForceLocal(true);

	plLocation loc = clickNode->GetLocation();
	plSceneObject *obj = clickNode->GetSceneObject();

	// Create and register the VolumeGadget's logic component
	plLogicModifier *logic = TRACKED_NEW plLogicModifier;
	plKey logicKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), logic, clickNode->GetLocation());
	hsgResMgr::ResMgr()->AddViaNotify(logicKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

	fLogicModKeys[clickNode] = logicKey;


	return true;
}


hsBool plClickableComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	bool ignoreProxyRegion = (fCompPB->GetInt(kClickableIgnoreProxyRegion) != 0);

	//
	// Error checking
	//
	plMaxNode* clickProxyNode = node;
	if (fCompPB->GetInt(kClickableUseProxy))
	{
		clickProxyNode = (plMaxNode*)fCompPB->GetINode(kClickableProxy);
		if (!clickProxyNode || !clickProxyNode->CanConvert())
		{
			pErrMsg->Set(true,
						"Clickable Error",
						"The Clickable '%s' on node '%s' is set to use a proxy but doesn't have one, or it didn't convert.\n"
						"The node the Clickable is attached to will be used instead.",
						GetINode()->GetName(), node->GetName()).Show();
			pErrMsg->Set(false);

			clickProxyNode = node;
		}
	}

	plMaxNode* detectNode = (plMaxNode*)fCompPB->GetINode(kClickableProxyRegion);
	if ((!detectNode || !detectNode->CanConvert()) && (!ignoreProxyRegion))
	{
		pErrMsg->Set(true,
					"Clickable Error",
					"The Clickable '%s' on node '%s' has a required region that is missing, or didn't convert.\n"
					"The export will be aborted.",
					GetINode()->GetName(), node->GetName()).Show();
		return false;
	}


	plLocation loc = clickProxyNode->GetLocation();
	plSceneObject *obj = clickProxyNode->GetSceneObject();
	
	plKey logicKey = fLogicModKeys[clickProxyNode];
	plLogicModifier *logic = plLogicModifier::ConvertNoRef(logicKey->GetObjectPtr());
	logic->fMyCursor = plCursorChangeMsg::kCursorPoised;
	
	if (fCompPB->GetInt(kClickableOneShot))
		logic->SetFlag(plLogicModBase::kOneShot);

	hsTArray<plKey> receivers;
	IGetReceivers(node, receivers);
	for (int i = 0; i < receivers.Count(); i++)
		logic->AddNotifyReceiver(receivers[i]);

		// Create the detector
	plDetectorModifier *detector = nil;
	detector = TRACKED_NEW plPickingDetector;

	// Register the detector
	plKey detectorKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), detector, loc);
	hsgResMgr::ResMgr()->AddViaNotify(detectorKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

	// create and register the CONDITIONS for the DETECTOR's Logic Modifier
	plActivatorConditionalObject* activatorCond = TRACKED_NEW plActivatorConditionalObject;
	plKey activatorKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), activatorCond, loc);
	
	//
	// Create required region
	//
	// need a player in box condition here...
	// first a detector-any for the box
	if (!ignoreProxyRegion)
	{
		plObjectInVolumeDetector* pCDet = TRACKED_NEW plObjectInVolumeDetector(plCollisionDetector::kTypeAny);
		
		plKey pCDetKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), pCDet, loc);
		hsgResMgr::ResMgr()->AddViaNotify(pCDetKey, TRACKED_NEW plObjRefMsg(detectNode->GetSceneObject()->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
		pCDet->AddLogicObj(logicKey);

		// then an object-in-box condition for the logic mod
		plObjectInBoxConditionalObject* boxCond = TRACKED_NEW plObjectInBoxConditionalObject;
		plKey boxCondKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), boxCond, loc);
		logic->AddCondition(boxCond);
	}

	//
	// How do we feel about player facing
	//
	plFacingConditionalObject* facingCond = TRACKED_NEW plFacingConditionalObject;
	facingCond->SetDirectional(fCompPB->GetInt(kClickableDirectional));
	int deg = fCompPB->GetInt(kClickableDegrees);
	if (deg > 180)
		deg = 180;
	hsScalar rad = hsScalarDegToRad(deg);
	facingCond->SetTolerance(hsCosine(rad));
	plKey facingKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), facingCond, loc);
	
	detector->AddLogicObj(logicKey);	 // send messages to this logic component
	activatorCond->SetActivatorKey(detectorKey); // Tells the activator condition to look for stimulus from the detector

	logic->AddCondition(activatorCond); // add this activator condition
	logic->AddCondition(facingCond);

	logic->SetDisabled(!fCompPB->GetInt(kClickableEnabled));

	// If this is for the SceneViewer, set the local only flag since the read function will never be called
	if (plConvert::Instance().IsForSceneViewer())
		logic->SetLocalOnly(true);

	return true;
}



//
// special physical you can walk through and click with mouse
//

class plNoBlkClickableComponent : public plComponent
{
public:
	plNoBlkClickableComponent();
	void DeleteThis() { delete this; }

	hsBool SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg); 
	hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; }
	hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; } 

	virtual void CollectNonDrawables(INodeTab& nonDrawables) { AddTargetsToList(nonDrawables); }
};

OBSOLETE_CLASS_DESC(plNoBlkClickableComponent, gNoBlkClickableDesc, "(ex)Non Physical Clickable Proxy",  "(ex)Non Physical Clickable Proxy", COMP_TYPE_PHYSICAL, Class_ID(0x66325afc, 0x253a3760))

ParamBlockDesc2 gNoBlkClickableBlock
(
	plComponent::kBlkComp, _T("NonPhysicalClickableProxy"), 0, &gNoBlkClickableDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp,

	end
);

plNoBlkClickableComponent::plNoBlkClickableComponent()
{
	fClassDesc = &gNoBlkClickableDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plNoBlkClickableComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
	return true;
}