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

#include "../MaxMain/plMaxNode.h"
#include "../MaxExport/plExportProgressBar.h"

#include "hsTypes.h"

#include "plShadowComponents.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnMessage/plObjRefMsg.h"

#include "../plGLight/plLightInfo.h"
#include "../plGLight/plShadowCaster.h"
#include "../plGLight/plPointShadowMaster.h"
#include "../plGLight/plDirectShadowMaster.h"

#include "hsResMgr.h"

void DummyCodeIncludeFuncShadow()
{
}

static UInt16 QualityBitToMask(int q) { return ~((1 << q) - 1); }

#define WM_ROLLOUT_OPEN WM_USER+1
static const int kNumQualities = 4;
static const char* kQualityStrings[kNumQualities] = {
	"Low",
	"Medium",
	"High",
	"Ultra"
};

template <class T> class plQualityProc : public ParamMap2UserDlgProc
{
public:
	BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
	{
		switch (msg)
		{
		case WM_INITDIALOG:
			{
				PostMessage(hWnd, WM_ROLLOUT_OPEN, 0, 0);

				HWND cbox = GetDlgItem(hWnd, IDC_COMP_SHADOW_QUALITY);
				int i;
				for( i = 0; i < kNumQualities; i++ )
				{
					SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM)kQualityStrings[i]);
				}
				SendMessage(cbox, CB_SETCURSEL, map->GetParamBlock()->GetInt(T::kQuality), 0);

			}
			return true;

		case WM_COMMAND:
			switch( LOWORD(wParam) )
			{
			case IDC_COMP_SHADOW_QUALITY:
				map->GetParamBlock()->SetValue(T::kQuality, t, SendMessage(GetDlgItem(hWnd, LOWORD(wParam)), CB_GETCURSEL, 0, 0));
				return TRUE;
			}
			break;
		}

		return false;
	}
	void DeleteThis() {}
};



////////////////////////////////////////////////////////////////////////////////////////////////////
// Contains (in order)
// ShadowCast
// ShadowRcv
// ShadowLight


////////////////////////////////////////////////////////////////////////////////////////////////////
// ShadowCast

CLASS_DESC(plShadowCastComponent, gShadowCastDesc, "Shadow Caster",  "ShadowCast", COMP_TYPE_SHADOW, SHADOWCAST_COMP_CID)


static plQualityProc<plShadowCastComponent> gCastQualityProc;

ParamBlockDesc2 gShadowCastBk
(
	plComponent::kBlkComp, _T("ShadowCast"), 0, &gShadowCastDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_SHADOW_CAST, IDS_COMP_SHADOW_CAST,  0, 0, &gCastQualityProc,

	plShadowCastComponent::kSelfShadow,	_T("SelfShadow"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_CAST_SELFSHADOW,
		end,

	plShadowCastComponent::kBlur,	_T("Blur"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_CAST_BLUR,
		p_enable_ctrls,		1, plShadowCastComponent::kBlurScale,
		end,

	plShadowCastComponent::kBlurScale, _T("BlurScale"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 100.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_CAST_BLURSCALE, IDC_COMP_SHADOW_CAST_BLURSCALE_SPIN, 1.0,
		end,	

	plShadowCastComponent::kAtten,	_T("Atten"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_CAST_ATTEN,
		p_enable_ctrls,		1, plShadowCastComponent::kAttenScale,
		end,

	plShadowCastComponent::kAttenScale, _T("AttenScale"), TYPE_FLOAT, 	0, 0,	
		p_default, 100.0,
		p_range, 25.0, 1000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_CAST_ATTENSCALE, IDC_COMP_SHADOW_CAST_ATTENSCALE_SPIN, 1.0,
		end,	

	plShadowCastComponent::kBoost, _T("Boost"), TYPE_FLOAT, 	0, 0,	
		p_default, 100.0,
		p_range, 0.0, 5000.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_CAST_BOOST, IDC_COMP_SHADOW_CAST_BOOST_SPIN, 1.0,
		end,	

	plShadowCastComponent::kQuality,	_T("Quality"),	TYPE_INT,	0, 0,
		p_default, 0,
		end,

	plShadowCastComponent::kLimitRes,	_T("Limit"),	TYPE_INT,	0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_CAST_LIMIT,
		end,

	end

);

plShadowCastComponent::plShadowCastComponent()
:	fCaster(nil)
{
	fClassDesc = &gShadowCastDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plShadowCastComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	plSceneObject* so = node->GetSceneObject();
	if( !so )
		return true;

	const float kBlurPercentToAbs = 1.e-2f * 1.5f;
	const float kAttenPercentToAbs = 1.e-2f;
	const float kBoostPercentToAbs = 1.e-2f;
	if( !fCaster )
	{
		fCaster = TRACKED_NEW plShadowCaster;
		plLoadMask lm(QualityBitToMask(fCompPB->GetInt(kQuality)), QualityBitToMask(0));
		hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), fCaster, node->GetLocation(), lm);
		fCaster->SetSelfShadow(fCompPB->GetInt(kSelfShadow));
		if( fCompPB->GetInt(kBlur) )
			fCaster->SetBlurScale(fCompPB->GetFloat(kBlurScale) * kBlurPercentToAbs);
		if( fCompPB->GetInt(kAtten) )
			fCaster->SetAttenScale(fCompPB->GetFloat(kAttenScale) * kAttenPercentToAbs);
		fCaster->SetBoost(fCompPB->GetFloat(kBoost) * kBoostPercentToAbs);
		if( fCompPB->GetInt(kLimitRes) )
			fCaster->SetLimitRes(true);
	}

	AddShadowCastModifier(so, fCaster);

	return true;
}

hsBool plShadowCastComponent::SetupProperties(plMaxNode *pNode,  plErrorMsg *pErrMsg)
{
	fCaster = nil;
	return true;
}

hsBool plShadowCastComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
	return true;
}

hsBool plShadowCastComponent::AddShadowCastModifier(plMaxNode* pNode, plShadowCaster* caster)
{
	if( !pNode->CanConvert() )
		return false;

	plSceneObject* so = pNode->GetSceneObject();
	if( !so )
		return false;

	return plShadowCastComponent::AddShadowCastModifier(so, caster);
}

hsBool plShadowCastComponent::AddShadowCastModifier(plSceneObject* so, plShadowCaster* caster)
{
	// First off, ensure that we NEVER NEVER NEVER have more than one shadowcaster on an object.
	// That would be BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD BAD.
	int i;
	for( i = 0; i < so->GetNumModifiers(); i++ )
	{
		if( plShadowCaster::ConvertNoRef(so->GetModifier(i)) )
			return false;
	}

	// Okay, we're clear, just add via notify.
	hsgResMgr::ResMgr()->AddViaNotify(caster->GetKey(), TRACKED_NEW plObjRefMsg(so->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// ShadowRcv

CLASS_DESC(plShadowRcvComponent, gShadowRcvDesc, "Shadow Receiver",  "ShadowRcv", COMP_TYPE_SHADOW, SHADOWRCV_COMP_CID)



ParamBlockDesc2 gShadowRcvBk
(
	plComponent::kBlkComp, _T("ShadowRcv"), 0, &gShadowRcvDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_SHADOW_RCV, IDS_COMP_SHADOW_RCV,  0, 0, nil,

	plShadowRcvComponent::kForceRadio, _T("ForceShadow"),		TYPE_INT, 		0, 0,
		p_ui,		TYPE_RADIO, 2,	IDC_RADIO_FORCE_ON,					IDC_RADIO_FORCE_OFF,
		p_vals,						plShadowRcvComponent::kForceOn,	plShadowRcvComponent::kForceOff,
		p_default, plShadowRcvComponent::kForceOff,
		end,
	end

);

plShadowRcvComponent::plShadowRcvComponent()
{
	fClassDesc = &gShadowRcvDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plShadowRcvComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	return true;
}

hsBool plShadowRcvComponent::SetupProperties(plMaxNode *pNode,  plErrorMsg *pErrMsg)
{
	if( fCompPB->GetInt(kForceRadio) == kForceOn )
	{
		pNode->SetForceShadow(true);
		pNode->SetNoShadow(false);
	}
	else if( fCompPB->GetInt(kForceRadio) == kForceOff )
	{
		pNode->SetForceShadow(false);
		pNode->SetNoShadow(true);
	}
	return true;
}

hsBool plShadowRcvComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
	return true;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// ShadowLight

CLASS_DESC(plShadowLightComponent, gShadowLightDesc, "Shadow Light",  "ShadowLight", COMP_TYPE_SHADOW, SHADOWLIGHT_COMP_CID)


static plQualityProc<plShadowLightComponent> gLightQualityProc;

ParamBlockDesc2 gShadowLightBk
(
	plComponent::kBlkComp, _T("ShadowLight"), 0, &gShadowLightDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_SHADOW_LIGHT, IDS_COMP_SHADOW_LIGHT,  0, 0, &gLightQualityProc,

	plShadowLightComponent::kFalloff, _T("Falloff"), TYPE_FLOAT, 	0, 0,	
		p_default, 10.0,
		p_range, 5.0, 50.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_LIGHT_FALLOFF, IDC_COMP_SHADOW_LIGHT_FALLOFF_SPIN, 1.0,
		end,	

	plShadowLightComponent::kMaxDist, _T("MaxDist"), TYPE_FLOAT, 	0, 0,	
		p_default, 0.0,
		p_range, 0.0, 500.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_LIGHT_MAXDIST, IDC_COMP_SHADOW_LIGHT_MAXDIST_SPIN, 1.0,
		end,	

	plShadowLightComponent::kPower, _T("Power"), TYPE_FLOAT, 	0, 0,	
		p_default, 100.0,
		p_range, 0.0, 200.0,
		p_ui,	TYPE_SPINNER,	EDITTYPE_POS_FLOAT,	
		IDC_COMP_SHADOW_LIGHT_POWER, IDC_COMP_SHADOW_LIGHT_POWER_SPIN, 1.0,
		end,	

	plShadowLightComponent::kShadowOnly,	_T("ShadowOnly"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_LIGHT_SHADOWONLY,
		end,

	plShadowLightComponent::kObeyGroups,	_T("ObeyGroups"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_LIGHT_OBEYGROUPS,
		end,

	plShadowLightComponent::kSelfShadow,	_T("SelfShadow"),	TYPE_BOOL, 0, 0,
		p_default,	FALSE,
		p_ui,	TYPE_SINGLECHEKBOX, IDC_COMP_SHADOW_LIGHT_SELFSHADOW,
		end,

	plShadowLightComponent::kQuality,	_T("Quality"),	TYPE_INT,	0, 0,
		p_default, 0,
		end,

	end

);

plShadowLightComponent::plShadowLightComponent()
{
	fClassDesc = &gShadowLightDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plShadowLightComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	plSceneObject* so = node->GetSceneObject();
	if( !so )
		return true;

	plLightInfo* liInfo = plLightInfo::ConvertNoRef(so->GetGenericInterface(plLightInfo::Index()));
	if( !liInfo )
		return true;

	if( fCompPB->GetInt(kShadowOnly) )
		liInfo->SetProperty(plLightInfo::kLPShadowOnly, true);

	if( fCompPB->GetInt(kObeyGroups) )
		liInfo->SetProperty(plLightInfo::kLPShadowLightGroup, true);

	plDirectionalLightInfo* dirLiInfo = plDirectionalLightInfo::ConvertNoRef(liInfo);
	if( dirLiInfo )
		return IAddDirectMaster(node, so);

	plOmniLightInfo* omniLiInfo = plOmniLightInfo::ConvertNoRef(liInfo);
	if( omniLiInfo )
		return IAddPointMaster(node, so);

	plSpotLightInfo* spotLiInfo = plSpotLightInfo::ConvertNoRef(liInfo);
	if( spotLiInfo )
		return IAddPointMaster(node, so);

	return true;
}

hsBool plShadowLightComponent::IAddDirectMaster(plMaxNode* node, plSceneObject* so)
{
	plDirectShadowMaster* directMaster = TRACKED_NEW plDirectShadowMaster;

	plLoadMask lm(QualityBitToMask(fCompPB->GetInt(kQuality)), QualityBitToMask(0));
	hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), directMaster, node->GetLocation(), lm);

	directMaster->SetAttenDist(fCompPB->GetFloat(kFalloff));

	directMaster->SetMaxDist(fCompPB->GetFloat(kMaxDist));

	directMaster->SetPower(fCompPB->GetFloat(kPower) * 1.e-2f);

	directMaster->SetProperty(plShadowMaster::kSelfShadow, fCompPB->GetInt(kSelfShadow));

	hsgResMgr::ResMgr()->AddViaNotify(directMaster->GetKey(), TRACKED_NEW plObjRefMsg(so->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
	return true;
}

hsBool plShadowLightComponent::IAddPointMaster(plMaxNode* node, plSceneObject* so)
{
	plPointShadowMaster* pointMaster = TRACKED_NEW plPointShadowMaster;

	plLoadMask lm(QualityBitToMask(fCompPB->GetInt(kQuality)), QualityBitToMask(0));
	hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), pointMaster, node->GetLocation(), lm);

	pointMaster->SetAttenDist(fCompPB->GetFloat(kFalloff));

	pointMaster->SetMaxDist(fCompPB->GetFloat(kMaxDist));

	pointMaster->SetPower(fCompPB->GetFloat(kPower) * 1.e-2f);

	pointMaster->SetProperty(plShadowMaster::kSelfShadow, fCompPB->GetInt(kSelfShadow));

	hsgResMgr::ResMgr()->AddViaNotify(pointMaster->GetKey(), TRACKED_NEW plObjRefMsg(so->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kInterface), plRefFlags::kActiveRef);

	return true;
}

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

hsBool plShadowLightComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
	return true;
}