OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
81 Branches
23 Tags
172 MiB
Tree: ecb7d8b566
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ecb7d8b566'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plFootPrintComponent.cpp

1795 lines
53 KiB
Raw Normal View History Unescape

Initial Commit of CyanWorlds.com Engine Open Source Client/Plugin
14 years ago
/*==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/plPlasmaRefMsgs.h"
#include "plPickNode.h"
#include "../MaxMain/plMaxNode.h"
#include "../MaxExport/plExportProgressBar.h"
#include "../MaxConvert/hsMaterialConverter.h"
#include "hsTypes.h"
#include "plTweak.h"
#include "hsResMgr.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../plDrawable/plDynaFootMgr.h"
#include "../plDrawable/plDynaRippleMgr.h"
#include "../plDrawable/plDynaRippleVSMgr.h"
#include "../plDrawable/plDynaBulletMgr.h"
#include "../plDrawable/plDynaPuddleMgr.h"
#include "../plDrawable/plDynaTorpedoMgr.h"
#include "../plDrawable/plDynaTorpedoVSMgr.h"
#include "../plDrawable/plDynaWakeMgr.h"
#include "../plDrawable/plCutter.h"
#include "../plModifier/plDecalEnableMod.h"
#include "../plDrawable/plPrintShape.h"
#include "../plDrawable/plActivePrintShape.h"
#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayer.h"
#include "plWaterComponent.h"
#include "../plDrawable/plWaveSetBase.h"
#include "plParticleComponents.h"
void DummyCodeIncludeFuncFootPrint()
{
}
const Class_ID FOOTPRINT_COMP_CID(0x5d553f57, 0x42344c5e);
const Class_ID RIPPLE_COMP_CID(0x750e1b2a, 0x4ad10f15);
const Class_ID PUDDLE_COMP_CID(0x2f800331, 0x640f4914);
const Class_ID WAKE_COMP_CID(0x714b6b6b, 0xa937ff4);
const Class_ID BULLET_COMP_CID(0x208c05d7, 0x41540df2);
const Class_ID TORPEDO_COMP_CID(0x72b85c86, 0xe2b0b40);
const Class_ID DIRTY_COMP_CID(0x500f1fd3, 0x508c4486);
class plFootPrintComponent : public plComponent
{
protected:
plDynaDecalMgr* fDecalMgr;
bool fValid;
bool fNotifiesSetup;
hsBool ISetupNotifies(plMaxNode* node, plErrorMsg* pErrMsg);
hsBool ISetupDecalMgr(plMaxNode* node, plErrorMsg* pErrMsg, plDynaDecalMgr* decalMgr);
hsBool ICreateDecalMaterials(plMaxNode* node, plErrorMsg* pErrMsg);
hsBool ISetupColorDecalMaterials(plMaxNode* node, plErrorMsg* pErrMsg);
hsBool ISetupParticles(plMaxNode* node, plErrorMsg* pErrMsg);
static plParticleComponent* IGetParticleComp(INode* node);
virtual void IFakeParams();
public:
enum
{
kWidth,
kLength,
kFadeIn,
kFadeOut,
kLifeSpan,
kLayer,
kBlend,
kDirtyTime,
kNotifies,
kIntensity,
kParticles,
kPartyTime
};
enum
{
kAlpha,
kMADD,
kAdd,
kMult
};
plFootPrintComponent();
virtual ~plFootPrintComponent();
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);
virtual hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg);
static plDynaDecalMgr* GetDecalMgr(INode* node);
};
CLASS_DESC(plFootPrintComponent, gFootPrintCompDesc, "Foot Print", "FootPrint", COMP_TYPE_FOOTPRINT, FOOTPRINT_COMP_CID)
class plWetProc : public ParamMap2UserDlgProc
{
public:
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
}
return true;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ADD_NOTIFY)
{
std::vector<Class_ID> cids;
cids.push_back(FOOTPRINT_COMP_CID);
cids.push_back(RIPPLE_COMP_CID);
cids.push_back(PUDDLE_COMP_CID);
cids.push_back(WAKE_COMP_CID);
IParamBlock2 *pb = map->GetParamBlock();
plPick::Node(pb, plFootPrintComponent::kNotifies, &cids, false, false);
map->Invalidate(plFootPrintComponent::kNotifies);
return TRUE;
}
else
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ADD_PARTICLE)
{
std::vector<Class_ID> cids;
cids.push_back(PARTICLE_SYSTEM_COMPONENT_CLASS_ID);
IParamBlock2 *pb = map->GetParamBlock();
plPick::Node(pb, plFootPrintComponent::kParticles, &cids, false, false);
map->Invalidate(plFootPrintComponent::kParticles);
return TRUE;
}
break;
}
return false;
}
void DeleteThis() {}
};
static plWetProc gWetProc;
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gFootPrintBk
(
plComponent::kBlkComp, _T("FootPrint"), 0, &gFootPrintCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_FOOTPRINT, IDS_COMP_FOOTPRINT, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 400.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_WIDTH, IDC_COMP_FP_WIDTH_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 400.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 1.0,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 10.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
p_default, 30.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.1,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
p_default, 0.25,
p_range, 0.1, 5.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
hsBool plFootPrintComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
// If we don't have a valid layer, we're screwed. Throw up a warning
// and shutdown.
if( !fCompPB->GetTexmap(kLayer) )
{
pErrMsg->Set(true, GetINode()->GetName(), "No layer setup. Ignoring Footprint generator").CheckAndAsk();
pErrMsg->Set(false);
fValid = false;
return true;
}
fDecalMgr = nil;
fValid = true;
fNotifiesSetup = false;
return true;
}
hsBool plFootPrintComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
ISetupDecalMgr(node, pErrMsg, TRACKED_NEW plDynaFootMgr);
}
return true;
}
hsBool plFootPrintComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
if( !fNotifiesSetup )
ISetupNotifies(node, pErrMsg);
// Add this node's object to our DynaDecalMgr.
hsgResMgr::ResMgr()->AddViaNotify(node->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefTarget), plRefFlags::kActiveRef);
return true;
}
hsBool plFootPrintComponent::DeInit(plMaxNode *node, plErrorMsg *pErrMsg)
{
fDecalMgr = nil;
return true;
}
plFootPrintComponent::plFootPrintComponent()
: fDecalMgr(nil)
{
fClassDesc = &gFootPrintCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plFootPrintComponent::~plFootPrintComponent()
{
}
void plFootPrintComponent::IFakeParams()
{
fCompPB->SetValue(kFadeIn, TimeValue(0), 0.1f);
fCompPB->SetValue(kFadeOut, TimeValue(0), fCompPB->GetFloat(kLifeSpan) * 0.25f);
}
hsBool plFootPrintComponent::ISetupDecalMgr(plMaxNode* node, plErrorMsg* pErrMsg, plDynaDecalMgr* decalMgr)
{
IFakeParams();
fDecalMgr = decalMgr;
plKey mgrKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), fDecalMgr, node->GetLocation());
float width = fCompPB->GetFloat(kWidth) * 1.e-2f;
float length = fCompPB->GetFloat(kLength) * 1.e-2f;
float wetTime = fCompPB->GetFloat(kDirtyTime);
float fadeIn = fCompPB->GetFloat(kFadeIn);
float fadeOut = fCompPB->GetFloat(kFadeOut);
float lifeSpan = fCompPB->GetFloat(kLifeSpan);
float intensity = fCompPB->GetFloat(kIntensity) * 1.e-2f;
float partyTime = fCompPB->GetFloat(kPartyTime);
const hsScalar kHeightHack = 1.f;
fDecalMgr->SetScale(hsVector3(width, length, kHeightHack));
const float kMinFadeOut = 1.e-2f;
if( fadeOut > lifeSpan - kMinFadeOut)
fadeOut = lifeSpan - kMinFadeOut;
if( fadeIn > lifeSpan - fadeOut )
fadeIn = lifeSpan - fadeOut;
fDecalMgr->SetWetLength(wetTime);
fDecalMgr->SetRampEnd(fadeIn);
fDecalMgr->SetDecayStart(lifeSpan - fadeOut);
fDecalMgr->SetLifeSpan(lifeSpan);
fDecalMgr->SetIntensity(intensity);
fDecalMgr->SetPartyTime(partyTime);
if( !ICreateDecalMaterials(node, pErrMsg) )
{
delete fDecalMgr;
fDecalMgr = nil;
return fValid = false;
}
hsgResMgr::ResMgr()->AddViaNotify(mgrKey, TRACKED_NEW plNodeRefMsg(node->GetRoomKey(), plRefMsg::kOnCreate, -1, plNodeRefMsg::kGeneric), plRefFlags::kActiveRef);
ISetupParticles(node, pErrMsg);
return true;
}
hsBool plFootPrintComponent::ISetupNotifies(plMaxNode* node, plErrorMsg* pErrMsg)
{
int num = fCompPB->Count(kNotifies);
int i;
for( i = 0; i < num; i++ )
{
plDynaDecalMgr* slave = GetDecalMgr(fCompPB->GetINode(kNotifies, TimeValue(0), i));
if( slave )
{
slave->SetWaitOnEnable(true);
fDecalMgr->AddNotify(slave->GetKey());
}
}
fNotifiesSetup = true;
return true;
}
hsBool plFootPrintComponent::ISetupParticles(plMaxNode* node, plErrorMsg* pErrMsg)
{
int num = fCompPB->Count(kParticles);
if( !num )
return true;
int i;
for( i = 0; i < num; i++ )
{
plParticleComponent* partyComp = IGetParticleComp(fCompPB->GetINode(kParticles, TimeValue(0), i));
if( partyComp && partyComp->NumTargets() )
{
plMaxNodeBase* partyNode = nil;
const int numTarg = partyComp->NumTargets();
int j;
for( j = 0; j < numTarg; j++ )
{
partyNode = partyComp->GetTarget(j);
if( partyNode )
break;
}
if( partyNode )
{
plSceneObject* obj = partyNode->GetSceneObject();
if( obj )
{
hsgResMgr::ResMgr()->AddViaNotify(obj->GetKey(),
new plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefPartyObject), plRefFlags::kPassiveRef);
}
}
plConst(int) kNumEmitters(3);
partyComp->SetEmitterReserve(kNumEmitters);
}
}
return true;
}
hsBool plFootPrintComponent::ICreateDecalMaterials(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( fCompPB->GetInt(kBlend) != kAlpha )
return ISetupColorDecalMaterials(node, pErrMsg);
hsGMaterial* matRTShade = hsMaterialConverter::Instance().NonAlphaHackPrint(node, fCompPB->GetTexmap(kLayer), hsGMatState::kBlendAlpha);
if( !matRTShade )
return fValid = false;
hsgResMgr::ResMgr()->AddViaNotify(matRTShade->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefMatRTShade), plRefFlags::kActiveRef);
hsGMaterial* matPreShade = hsMaterialConverter::Instance().AlphaHackPrint(node, fCompPB->GetTexmap(kLayer), hsGMatState::kBlendAlpha);
hsgResMgr::ResMgr()->AddViaNotify(matPreShade->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefMatPreShade), plRefFlags::kActiveRef);
return true;
}
hsBool plFootPrintComponent::ISetupColorDecalMaterials(plMaxNode* node, plErrorMsg* pErrMsg)
{
UInt32 blendFlags = 0;
switch( fCompPB->GetInt(kBlend) )
{
case kMADD:
blendFlags = hsGMatState::kBlendMADD;
break;
case kAdd:
blendFlags = hsGMatState::kBlendAdd;
break;
case kMult:
blendFlags = hsGMatState::kBlendMult;
break;
default:
hsAssert(false, "Unknown blend mode");
blendFlags = hsGMatState::kBlendMADD; // cuz it's my fave.
break;
}
hsGMaterial* matRTShade = hsMaterialConverter::Instance().NonAlphaHackPrint(node, fCompPB->GetTexmap(kLayer), blendFlags);
if( blendFlags & hsGMatState::kBlendMult )
{
plLayer* layer = plLayer::ConvertNoRef(matRTShade->GetLayer(0)->BottomOfStack());
if( !layer )
return fValid = false;
layer->SetBlendFlags(layer->GetBlendFlags() | hsGMatState::kBlendInvertFinalColor);
}
hsgResMgr::ResMgr()->AddViaNotify(matRTShade->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefMatRTShade), plRefFlags::kActiveRef);
return true;
}
plParticleComponent* plFootPrintComponent::IGetParticleComp(INode* node)
{
if( !node )
return nil;
plComponentBase *comp = ((plMaxNodeBase*)node)->ConvertToComponent();
if( comp == nil )
return nil;
if( comp->ClassID() == PARTICLE_SYSTEM_COMPONENT_CLASS_ID )
{
plParticleComponent* party = (plParticleComponent*)comp;
return party;
}
return nil;
}
plDynaDecalMgr* plFootPrintComponent::GetDecalMgr(INode* node)
{
if( !node )
return nil;
plComponentBase *comp = ((plMaxNodeBase*)node)->ConvertToComponent();
if( comp == nil )
return nil;
if( (comp->ClassID() == FOOTPRINT_COMP_CID)
|| (comp->ClassID() == RIPPLE_COMP_CID)
|| (comp->ClassID() == PUDDLE_COMP_CID)
|| (comp->ClassID() == WAKE_COMP_CID)
)
{
plFootPrintComponent* foot = (plFootPrintComponent*)comp;
return foot->fDecalMgr;
}
return nil;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
class plRippleComponent : public plFootPrintComponent
{
protected:
virtual void IFakeParams();
public:
plRippleComponent();
virtual ~plRippleComponent();
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);
};
CLASS_DESC(plRippleComponent, gRippleCompDesc, "Ripple", "Ripple", COMP_TYPE_FOOTPRINT, RIPPLE_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gRippleBk
(
plComponent::kBlkComp, _T("Ripple"), 0, &gRippleCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_RIPPLE, IDS_COMP_RIPPLE, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_WIDTH, IDC_COMP_FP_WIDTH_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
// p_default, 1.0,
// p_range, 0.25, 10.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 0.1,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 3.5,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
// p_default, 5.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.25,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
p_default, 0.25,
p_range, 0.1, 5.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
void plRippleComponent::IFakeParams()
{
fCompPB->SetValue(kLength, TimeValue(0), fCompPB->GetFloat(kWidth));
fCompPB->SetValue(kFadeIn, TimeValue(0), 0.25f);
fCompPB->SetValue(kLifeSpan, TimeValue(0), fCompPB->GetFloat(kWidth) * 1.e-2f * 0.5f);
fCompPB->SetValue(kFadeOut, TimeValue(0), fCompPB->GetFloat(kLifeSpan) * 0.80f);
}
hsBool plRippleComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plFootPrintComponent::SetupProperties(node, pErrMsg);
}
hsBool plRippleComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
plDynaRippleMgr* ripple = nil;
if( node->GetVS() || node->UserPropExists("XXXWaterColor") )
{
ripple = TRACKED_NEW plDynaRippleVSMgr;
}
else
{
ripple = TRACKED_NEW plDynaRippleMgr;
}
ISetupDecalMgr(node, pErrMsg, ripple);
if( fValid )
{
ripple->SetUVWAnim(hsVector3(3.f, 3.f, 3.f), hsVector3(1.f, 1.f, 1.f));
}
}
return true;
}
hsBool plRippleComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
if( !fNotifiesSetup )
{
plWaveSetBase* waveSet = plWaterComponent::GetWaveSetFromNode(node);
if( waveSet )
{
plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaRippleVSMgr::kRefWaveSetBase);
hsgResMgr::ResMgr()->AddViaNotify(waveSet->GetKey(), refMsg, plRefFlags::kPassiveRef);
}
ISetupNotifies(node, pErrMsg);
}
// Add this node's object to our DynaDecalMgr.
hsgResMgr::ResMgr()->AddViaNotify(node->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefTarget), plRefFlags::kActiveRef);
return true;
}
plRippleComponent::plRippleComponent()
{
fClassDesc = &gRippleCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plRippleComponent::~plRippleComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
class plPuddleComponent : public plRippleComponent
{
protected:
public:
plPuddleComponent();
virtual ~plPuddleComponent();
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);
};
CLASS_DESC(plPuddleComponent, gPuddleCompDesc, "Puddle", "Puddle", COMP_TYPE_FOOTPRINT, PUDDLE_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gPuddleBk
(
plComponent::kBlkComp, _T("Puddle"), 0, &gPuddleCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_PUDDLE, IDS_COMP_PUDDLE, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_WIDTH, IDC_COMP_FP_WIDTH_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
// p_default, 1.0,
// p_range, 0.25, 10.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 0.1,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 3.5,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
// p_default, 5.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.25,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
p_default, 0.25,
p_range, 0.1, 5.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
hsBool plPuddleComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plRippleComponent::SetupProperties(node, pErrMsg);
}
hsBool plPuddleComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
plDynaRippleMgr* puddle = TRACKED_NEW plDynaPuddleMgr;
ISetupDecalMgr(node, pErrMsg, puddle);
if( fValid )
{
puddle->SetUVWAnim(hsVector3(5.f, 5.f, 5.f), hsVector3(1.f, 1.f, 1.f));
}
}
return true;
}
hsBool plPuddleComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
if( !fNotifiesSetup )
ISetupNotifies(node, pErrMsg);
// Add this node's object to our DynaDecalMgr.
hsgResMgr::ResMgr()->AddViaNotify(node->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefTarget), plRefFlags::kActiveRef);
return true;
}
plPuddleComponent::plPuddleComponent()
{
fClassDesc = &gPuddleCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plPuddleComponent::~plPuddleComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
class plBulletComponent : public plFootPrintComponent
{
protected:
virtual void IFakeParams();
public:
plBulletComponent();
virtual ~plBulletComponent();
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);
};
CLASS_DESC(plBulletComponent, gBulletCompDesc, "Bullet", "Bullet", COMP_TYPE_FOOTPRINT, BULLET_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gBulletBk
(
plComponent::kBlkComp, _T("Bullet"), 0, &gBulletCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_BULLET, IDS_COMP_FP_BULLET, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 400.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_SCALE, IDC_COMP_FP_SCALE_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
// p_default, 100.0,
// p_range, 25.0, 400.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 1.0,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 10.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
p_default, 15.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.1,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
// p_default, 10.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
// p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
p_default, 0.25,
p_range, 0.1, 5.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
void plBulletComponent::IFakeParams()
{
fCompPB->SetValue(kLength, TimeValue(0), fCompPB->GetFloat(kWidth));
plFootPrintComponent::IFakeParams();
}
hsBool plBulletComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plFootPrintComponent::SetupProperties(node, pErrMsg);
}
hsBool plBulletComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
plDynaBulletMgr* bullet = TRACKED_NEW plDynaBulletMgr;
ISetupDecalMgr(node, pErrMsg, bullet);
}
return true;
}
hsBool plBulletComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
if( !fNotifiesSetup )
ISetupNotifies(node, pErrMsg);
// Add this node's object to our DynaDecalMgr.
hsgResMgr::ResMgr()->AddViaNotify(node->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefTarget), plRefFlags::kActiveRef);
return true;
}
plBulletComponent::plBulletComponent()
{
fClassDesc = &gBulletCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plBulletComponent::~plBulletComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
class plTorpedoComponent : public plRippleComponent
{
protected:
virtual void IFakeParams();
public:
plTorpedoComponent();
virtual ~plTorpedoComponent();
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);
};
CLASS_DESC(plTorpedoComponent, gTorpedoCompDesc, "Water Bullet", "WetBullet", COMP_TYPE_FOOTPRINT, TORPEDO_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gTorpedoBk
(
plComponent::kBlkComp, _T("Torpedo"), 0, &gTorpedoCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_TORPEDO, IDS_COMP_FP_TORPEDO, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_WIDTH, IDC_COMP_FP_WIDTH_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
// p_default, 1.0,
// p_range, 0.25, 10.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 0.1,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 3.5,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
p_default, 5.0,
p_range, 0.0, 10.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.25,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
p_default, 0.25,
p_range, 0.1, 5.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
void plTorpedoComponent::IFakeParams()
{
fCompPB->SetValue(kLength, TimeValue(0), fCompPB->GetFloat(kWidth));
fCompPB->SetValue(kFadeIn, TimeValue(0), 0.25f);
fCompPB->SetValue(kFadeOut, TimeValue(0), fCompPB->GetFloat(kLifeSpan) * 0.80f);
}
hsBool plTorpedoComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plRippleComponent::SetupProperties(node, pErrMsg);
}
hsBool plTorpedoComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
plDynaRippleMgr* torpedo;
if( node->GetVS() )
torpedo = TRACKED_NEW plDynaTorpedoVSMgr;
else
torpedo = TRACKED_NEW plDynaTorpedoMgr;
ISetupDecalMgr(node, pErrMsg, torpedo);
if( fValid )
{
torpedo->SetUVWAnim(hsVector3(5.f, 5.f, 5.f), hsVector3(1.f, 1.f, 1.f));
}
}
return true;
}
hsBool plTorpedoComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plRippleComponent::Convert(node, pErrMsg);
}
plTorpedoComponent::plTorpedoComponent()
{
fClassDesc = &gTorpedoCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plTorpedoComponent::~plTorpedoComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
class plWakeComponent : public plFootPrintComponent
{
protected:
virtual void IFakeParams();
public:
plWakeComponent();
virtual ~plWakeComponent();
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);
};
CLASS_DESC(plWakeComponent, gWakeCompDesc, "Wake", "Wake", COMP_TYPE_FOOTPRINT, WAKE_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gWakeBk
(
plComponent::kBlkComp, _T("Wake"), 0, &gWakeCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_WAKE, IDS_COMP_FP_WAKE, 0, 0, &gWetProc,
plFootPrintComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_WIDTH, IDC_COMP_FP_WIDTH_SPIN, 1.0,
end,
plFootPrintComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 25.0, 1000.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_LENGTH, IDC_COMP_FP_LENGTH_SPIN, 0.1,
end,
plFootPrintComponent::kFadeOut, _T("FadeOut"), TYPE_FLOAT, 0, 0,
// p_default, 3.5,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_FADEOUT, IDC_COMP_FP_FADEOUT_SPIN, 0.1,
end,
plFootPrintComponent::kLifeSpan, _T("LifeSpan"), TYPE_FLOAT, 0, 0,
// p_default, 5.0,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_LIFESPAN2, IDC_COMP_FP_LIFESPAN_SPIN2, 0.1,
end,
plFootPrintComponent::kFadeIn, _T("FadeIn"), TYPE_FLOAT, 0, 0,
// p_default, 0.25,
// p_range, 0.0, 300.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_RAMPEND, IDC_COMP_FP_RAMPEND_SPIN, 0.1,
end,
plFootPrintComponent::kLayer, _T("Layer"), TYPE_TEXMAP, 0, 0,
p_ui, TYPE_TEXMAPBUTTON, IDC_COMP_FP_TEXMAP,
end,
plFootPrintComponent::kBlend, _T("Blend"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_ALPHA, IDC_RADIO_MADD, IDC_RADIO_ADD, IDC_RADIO_MULT,
p_vals, plFootPrintComponent::kAlpha, plFootPrintComponent::kMADD, plFootPrintComponent::kAdd, plFootPrintComponent::kMult,
p_default, plFootPrintComponent::kAlpha,
end,
plFootPrintComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
plFootPrintComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plFootPrintComponent::kIntensity, _T("Intensity"), TYPE_FLOAT, 0, 0,
p_default, 100.0,
p_range, 0.0, 100.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_INTENSITY, IDC_COMP_FP_INTENSITY_SPIN, 1.0,
end,
plFootPrintComponent::kParticles, _T("Particles"), TYPE_INODE_TAB, 0, 0, 0,
// p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS2, 0, 0, IDC_DEL_TARGS2,
end,
plFootPrintComponent::kPartyTime, _T("PartyTime"), TYPE_FLOAT, 0, 0,
// p_default, 0.25,
// p_range, 0.1, 5.0,
// p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
// IDC_COMP_FP_PARTYTIME, IDC_COMP_FP_PARTYTIME_SPIN, 0.1,
end,
end
);
void plWakeComponent::IFakeParams()
{
fCompPB->SetValue(kFadeIn, TimeValue(0), 0.25f);
fCompPB->SetValue(kLifeSpan, TimeValue(0), fCompPB->GetFloat(kWidth) * 1.e-2f * 0.5f);
fCompPB->SetValue(kFadeOut, TimeValue(0), fCompPB->GetFloat(kLifeSpan) * 0.80f);
}
hsBool plWakeComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return plFootPrintComponent::SetupProperties(node, pErrMsg);
}
hsBool plWakeComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
// If we haven't already, create our DynaDecalMgr and stash it away.
if( !fDecalMgr )
{
plDynaWakeMgr* wake = TRACKED_NEW plDynaWakeMgr;
ISetupDecalMgr(node, pErrMsg, wake);
if( fValid )
{
wake->SetUVWAnim(hsVector3(5.f, 5.f, 5.f), hsVector3(1.f, 1.f, 1.f));
}
}
return true;
}
hsBool plWakeComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
if( !fNotifiesSetup )
ISetupNotifies(node, pErrMsg);
// Add this node's object to our DynaDecalMgr.
hsgResMgr::ResMgr()->AddViaNotify(node->GetKey(), TRACKED_NEW plGenRefMsg(fDecalMgr->GetKey(), plRefMsg::kOnCreate, 0, plDynaDecalMgr::kRefTarget), plRefFlags::kActiveRef);
return true;
}
plWakeComponent::plWakeComponent()
{
fClassDesc = &gWakeCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plWakeComponent::~plWakeComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
class plDirtyComponent : public plComponent
{
public:
enum
{
kDecals,
kDirtyTime
};
protected:
public:
plDirtyComponent();
virtual ~plDirtyComponent();
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);
};
CLASS_DESC(plDirtyComponent, gDirtyCompDesc, "Dirty/Wet Region", "Dirty/Wet", COMP_TYPE_FOOTPRINT, DIRTY_COMP_CID)
class plDirtyProc : public ParamMap2UserDlgProc
{
public:
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
}
return true;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ADD_DECAL)
{
std::vector<Class_ID> cids;
cids.push_back(FOOTPRINT_COMP_CID);
cids.push_back(RIPPLE_COMP_CID);
cids.push_back(PUDDLE_COMP_CID);
cids.push_back(WAKE_COMP_CID);
IParamBlock2 *pb = map->GetParamBlock();
plPick::Node(pb, plDirtyComponent::kDecals, &cids, false, false);
map->Invalidate(plDirtyComponent::kDecals);
return TRUE;
}
break;
}
return false;
}
void DeleteThis() {}
};
static plDirtyProc gDirtyProc;
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gDirtyBk
(
plComponent::kBlkComp, _T("Dirty"), 0, &gDirtyCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_DIRTY, IDS_COMP_FP_DIRTY, 0, 0, &gDirtyProc,
plDirtyComponent::kDecals, _T("Decals"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
plDirtyComponent::kDirtyTime, _T("DirtyTime"), TYPE_FLOAT, 0, 0,
p_default, 10.0,
p_range, 0.0, 300.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_FP_DIRTYTIME, IDC_COMP_FP_DIRTYTIME_SPIN, 0.1,
end,
end
);
hsBool plDirtyComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
return true;
}
hsBool plDirtyComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
return true;
}
hsBool plDirtyComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
// Check that this node has a physical interface, or all is for nought.
// Should throw up a warning if it doesn't have one, seems an easy thing
// to miss.
if( !node->IsPhysical() )
{
pErrMsg->Set(true, node->GetName(), "Has no physical component to notify %s Dirty/Wet component", GetINode()->GetName()).CheckAndAsk();
pErrMsg->Set(false);
return true;
}
plDecalEnableMod* enable = TRACKED_NEW plDecalEnableMod;
plKey modKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), enable, node->GetLocation());
int numDecals = fCompPB->Count(kDecals);
int i;
for( i = 0; i < numDecals; i++ )
{
INode* decalNode = fCompPB->GetINode(kDecals, TimeValue(0), i);
plDynaDecalMgr* decal = plFootPrintComponent::GetDecalMgr(decalNode);
if( decal )
{
decal->SetWaitOnEnable(true);
enable->AddDecalKey(decal->GetKey());
}
}
enable->SetWetLength(fCompPB->GetFloat(kDirtyTime));
hsgResMgr::ResMgr()->AddViaNotify(modKey, TRACKED_NEW plObjRefMsg(node->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
return true;
}
plDirtyComponent::plDirtyComponent()
{
fClassDesc = &gDirtyCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plDirtyComponent::~plDirtyComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
const Class_ID PRINTSHAPE_COMP_CID(0x208226a1, 0x2a6e67ba);
class plPrintShapeComponent : public plComponent
{
public:
enum
{
kWidth,
kLength,
kHeight
};
protected:
public:
plPrintShapeComponent();
virtual ~plPrintShapeComponent();
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);
};
CLASS_DESC(plPrintShapeComponent, gPrintShapeCompDesc, "Print Shape", "PrintShape", COMP_TYPE_FOOTPRINT, PRINTSHAPE_COMP_CID)
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gPrintShapeBk
(
plComponent::kBlkComp, _T("PrintShape"), 0, &gPrintShapeCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_PRINTSHAPE, IDS_COMP_FP_PRINTSHAPE, 0, 0, NULL,
plPrintShapeComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 0.45,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_WIDTH, IDC_COMP_WIDTH_SPIN, 0.1,
end,
plPrintShapeComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
p_default, 0.9,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_LENGTH, IDC_COMP_LENGTH_SPIN, 0.1,
end,
plPrintShapeComponent::kHeight, _T("Height"), TYPE_FLOAT, 0, 0,
p_default, 1.0,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_HEIGHT, IDC_COMP_HEIGHT_SPIN, 0.1,
end,
end
);
hsBool plPrintShapeComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
node->SetForceLocal(true);
return true;
}
hsBool plPrintShapeComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
return true;
}
hsBool plPrintShapeComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
plSceneObject* obj = node->GetSceneObject();
if( !obj )
return true;
plPrintShape* shape = TRACKED_NEW plPrintShape();
plKey shapeKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), shape, node->GetLocation());
shape->SetWidth(fCompPB->GetFloat(kWidth));
shape->SetLength(fCompPB->GetFloat(kLength));
shape->SetHeight(fCompPB->GetFloat(kHeight));
hsgResMgr::ResMgr()->AddViaNotify(shapeKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
return true;
}
plPrintShapeComponent::plPrintShapeComponent()
{
fClassDesc = &gPrintShapeCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plPrintShapeComponent::~plPrintShapeComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
const Class_ID ACTIVEPRINTSHAPE_COMP_CID(0x61b52046, 0x787734a5);
class plActivePrintShapeComponent : public plComponent
{
public:
enum
{
kWidth,
kLength,
kHeight,
kNotifies
};
protected:
public:
plActivePrintShapeComponent();
virtual ~plActivePrintShapeComponent();
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);
};
CLASS_DESC(plActivePrintShapeComponent, gActivePrintShapeCompDesc, "Active Shape", "ActiveShape", COMP_TYPE_FOOTPRINT, ACTIVEPRINTSHAPE_COMP_CID)
class plActiveProc : public ParamMap2UserDlgProc
{
public:
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
}
return true;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_ADD_NOTIFY2)
{
std::vector<Class_ID> cids;
cids.push_back(FOOTPRINT_COMP_CID);
cids.push_back(RIPPLE_COMP_CID);
cids.push_back(PUDDLE_COMP_CID);
cids.push_back(WAKE_COMP_CID);
IParamBlock2 *pb = map->GetParamBlock();
plPick::Node(pb, plActivePrintShapeComponent::kNotifies, &cids, false, false);
map->Invalidate(plActivePrintShapeComponent::kNotifies);
return TRUE;
}
break;
}
return false;
}
void DeleteThis() {}
};
static plActiveProc gActiveProc;
/////////////////////////////////////////////////////////////////////////////////////
ParamBlockDesc2 gActivePrintShapeBk
(
plComponent::kBlkComp, _T("ActivePrintShape"), 0, &gActivePrintShapeCompDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FP_ACTIVEPRINTSHAPE, IDS_COMP_FP_ACTIVEPRINTSHAPE, 0, 0, &gActiveProc,
plActivePrintShapeComponent::kWidth, _T("Width"), TYPE_FLOAT, 0, 0,
p_default, 0.45,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_WIDTH, IDC_COMP_WIDTH_SPIN, 0.1,
end,
plActivePrintShapeComponent::kLength, _T("Length"), TYPE_FLOAT, 0, 0,
p_default, 0.9,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_LENGTH, IDC_COMP_LENGTH_SPIN, 0.1,
end,
plActivePrintShapeComponent::kHeight, _T("Height"), TYPE_FLOAT, 0, 0,
p_default, 1.0,
p_range, 0.1, 30.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_HEIGHT, IDC_COMP_HEIGHT_SPIN, 0.1,
end,
plActivePrintShapeComponent::kNotifies, _T("Notifies"), TYPE_INODE_TAB, 0, 0, 0,
p_ui, TYPE_NODELISTBOX, IDC_LIST_TARGS, 0, 0, IDC_DEL_TARGS,
end,
end
);
hsBool plActivePrintShapeComponent::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
node->SetForceLocal(true);
return true;
}
hsBool plActivePrintShapeComponent::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
return true;
}
hsBool plActivePrintShapeComponent::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
plSceneObject* obj = node->GetSceneObject();
if( !obj )
return true;
plActivePrintShape* shape = TRACKED_NEW plActivePrintShape();
plKey shapeKey = hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), shape, node->GetLocation());
shape->SetWidth(fCompPB->GetFloat(kWidth));
shape->SetLength(fCompPB->GetFloat(kLength));
shape->SetHeight(fCompPB->GetFloat(kHeight));
int num = fCompPB->Count(kNotifies);
int i;
for( i = 0; i < num; i++ )
{
plDynaDecalMgr* notify = plFootPrintComponent::GetDecalMgr(fCompPB->GetINode(kNotifies, TimeValue(0), i));
if( notify )
{
shape->AddDecalKey(notify->GetKey());
}
}
hsgResMgr::ResMgr()->AddViaNotify(shapeKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
return true;
}
plActivePrintShapeComponent::plActivePrintShapeComponent()
{
fClassDesc = &gActivePrintShapeCompDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plActivePrintShapeComponent::~plActivePrintShapeComponent()
{
}
//////////////////////////////////////////////////////////////////////////////////////////////////////