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.
3 Commits
79 Branches
23 Tags
171 MiB
 
 
 
 
 
Tree: a363a783c5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a363a783c5'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plMiscComponents.cpp

2557 lines
71 KiB
Raw Blame History

/*==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 "plMiscComponents.h"
#include "plComponentReg.h"
#include "../../AssetMan/PublicInterface/MaxAssInterface.h"
#include "../MaxMain/plPlasmaRefMsgs.h"
#include "../MaxMain/plMaxNodeData.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pnSceneObject/plDrawInterface.h"
#include "../MaxMain/plPluginResManager.h"
#include "plgDispatch.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../pnMessage/plIntRefMsg.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "../plScene/plSceneNode.h"
#include "../MaxConvert/hsConverterUtils.h"
#include "../MaxConvert/hsControlConverter.h"
#include "../plInterp/plController.h"
#include "../MaxMain/plMaxNode.h"
#include "../pnKeyedObject/plKey.h"
#include "../plFile/plFileUtils.h"
// Follow mod
#include "../plInterp/plAnimPath.h"
#include "../pfAnimation/plFollowMod.h"
//Player Attention Related
#include "../pfCamera/plInterestingModifier.h"
//Player Start Position
#include "../plModifier/plSpawnModifier.h"
// RunTime related (Sprites, Billboards, LightMaps, etc., etc.)
#include "../pfAnimation/plViewFaceModifier.h" // ViewFace Comp
// Anim Related
#include "plMaxAnimUtils.h"
// CavView component.
#include "../plScene/plPostEffectMod.h"
// Location Related
#include "../plAgeDescription/plAgeDescription.h"
#include "../MaxMain/plMaxCFGFile.h"
#include "../MaxMain/plAgeDescInterface.h"
#include "../plFile/hsFiles.h"
#include "../plResMgr/plPageInfo.h"
#include "../plDrawable/plGeometrySpan.h"
#include "../MaxConvert/plConvert.h"
// ImageLib
#include "../plModifier/plImageLibMod.h"
#include "../MaxPlasmaMtls/Layers/plLayerTex.h"
#include "../MaxConvert/plLayerConverter.h"
#include "../plGImage/plBitmap.h"
void DummyCodeIncludeFuncMisc()
{
RegisterNotification(plPageInfoComponent::NotifyProc, nil, NOTIFY_FILE_POST_OPEN);
RegisterNotification(plPageInfoComponent::NotifyProc, nil, NOTIFY_SYSTEM_POST_RESET);
RegisterNotification(plPageInfoComponent::NotifyProc, nil, NOTIFY_SYSTEM_POST_NEW);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Interesting Component
//
//
//Class that accesses the paramblock below.
class plInterestingComponent : public plComponent
{
public:
plInterestingComponent();
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary below.
CLASS_DESC(plInterestingComponent, gInterestDesc, "Player Attention", "PlayerAttention", COMP_TYPE_MISC, Class_ID(0x6f48a7, 0x7ab86088))
enum
{
kInteresting, kCamInterestRadius, kCamInterestWeight
};
ParamBlockDesc2 gInterestBk
( // KLUDGE: not the defined block ID, but kept for backwards compat.
1, _T("Player Attention"), 0, &gInterestDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_INTEREST, IDS_COMP_INTERESTS, 0, 0, NULL,
// params
kInteresting, _T("interesting"), TYPE_STRING, 0, 0,
end,
kCamInterestRadius, _T("CamIntersestRadius"), TYPE_FLOAT, P_ANIMATABLE, 0,
p_default, 100.0f,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_INTEREST_EDIT1, IDC_COMP_INTEREST_SPIN1, 1.0f,
end,
kCamInterestWeight, _T("CamIntersestWeight"), TYPE_FLOAT, P_ANIMATABLE, 0,
p_range, 0.0, 1.0,
p_default, 1.0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_FLOAT,
IDC_COMP_INTEREST_EDIT2, IDC_COMP_INTEREST_SPIN2, 0.001f,
end,
end
);
plInterestingComponent::plInterestingComponent()
{
fClassDesc = &gInterestDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plInterestingComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
plInterestingModifier* pMod = TRACKED_NEW plInterestingModifier;
hsScalar loader = fCompPB->GetFloat(kCamInterestRadius);
pMod->SetInterestRadius(loader);
loader = fCompPB->GetFloat(kCamInterestWeight);
pMod->SetInterestWeight(loader);
node->AddModifier(pMod, IGetUniqueName(node));
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// PageInfo Component
//
//
class plPageInfoComponentProc : public ParamMap2UserDlgProc
{
protected:
HWND fhDlg;
IParamBlock2 *fPB;
void ILoadPages()
{
HWND hPageCombo = GetDlgItem(fhDlg, IDC_COMP_LOCATION_PAGECOMBO);
ComboBox_ResetContent(hPageCombo);
int idx = ComboBox_GetCurSel( GetDlgItem( fhDlg, IDC_COMP_LOCATION_AGECOMBO ) );
if( idx == CB_ERR )
return;
char *agePath = (char *)ComboBox_GetItemData( GetDlgItem( fhDlg, IDC_COMP_LOCATION_AGECOMBO ), idx );
if( agePath == nil )
return;
// Get the age description
plAgeDescription aged( agePath );
// Set the seqPrefix here. (Where else would you suggest?)
fPB->SetValue( plPageInfoComponent::kInfoSeqPrefix, 0, (int)aged.GetSequencePrefix() );
const char *curPage = fPB->GetStr(plPageInfoComponent::kInfoPage);
if (curPage && *curPage == '\0')
curPage = nil;
// Load the page combo and select the saved page (if it's in there)
plAgePage *page;
aged.SeekFirstPage();
while( ( page = aged.GetNextPage() ) != nil )
{
int idx = ComboBox_AddString(hPageCombo, page->GetName() );
if (curPage && !strcmp(page->GetName(), curPage))
ComboBox_SetCurSel(hPageCombo, idx);
ComboBox_SetItemData( hPageCombo, idx, (int)page->GetSeqSuffix() );
}
}
void IClearAges( HWND combo )
{
while( ComboBox_GetCount( combo ) > 0 )
{
char *path = (char *)ComboBox_GetItemData( combo, 0 );
if( path != nil )
delete [] path;
ComboBox_DeleteString( combo, 0 );
}
}
bool ILoadAges()
{
HWND hAgeCombo = GetDlgItem(fhDlg, IDC_COMP_LOCATION_AGECOMBO);
IClearAges( hAgeCombo );
hsTArray<char *> ageFiles;
plAgeDescInterface::BuildAgeFileList( ageFiles );
const char *curAge = fPB->GetStr(plPageInfoComponent::kInfoAge);
if (!curAge || *curAge == '\0')
curAge = "";
for( int i = 0; i < ageFiles.GetCount(); i++ )
{
char ageName[_MAX_FNAME];
_splitpath( ageFiles[ i ], nil, nil, ageName, nil );
int idx = ComboBox_AddString( hAgeCombo, ageName );
// Store the pathas the item data for later (so don't free it yet!)
ComboBox_SetItemData( hAgeCombo, idx, (LPARAM)ageFiles[ i ] );
if( !strcmp( ageName, curAge ) )
ComboBox_SetCurSel( hAgeCombo, idx );
}
return true;
}
public:
void DeleteThis() {}
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
fhDlg = hWnd;
fPB = map->GetParamBlock();
ILoadAges();
ILoadPages();
return TRUE;
}
case WM_DESTROY:
IClearAges( GetDlgItem( hWnd, IDC_COMP_LOCATION_AGECOMBO ) );
return TRUE;
case WM_COMMAND:
if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_COMP_LOCATION_AGECOMBO)
{
HWND hAgeCombo = (HWND)lParam;
int idx = ComboBox_GetCurSel(hAgeCombo);
if (idx != CB_ERR)
{
char buf[256];
ComboBox_GetText(hAgeCombo, buf, sizeof(buf));
fPB->SetValue(plPageInfoComponent::kInfoAge, 0, buf);
fPB->SetValue(plPageInfoComponent::kInfoPage, 0, "");
fPB->SetValue(plPageInfoComponent::kInfoSeqSuffix, 0, (int)-1 );
ILoadPages();
}
return TRUE;
}
if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_COMP_LOCATION_PAGECOMBO)
{
HWND hPageCombo = (HWND)lParam;
int idx = ComboBox_GetCurSel(hPageCombo);
if (idx != CB_ERR)
{
char buf[256];
ComboBox_GetText(hPageCombo, buf, sizeof(buf));
fPB->SetValue( plPageInfoComponent::kInfoPage, 0, buf );
fPB->SetValue( plPageInfoComponent::kInfoSeqSuffix, 0, ComboBox_GetItemData( hPageCombo, idx ) );
}
return TRUE;
}
return FALSE;
}
return FALSE;
}
};
// For the paramblock below.
static plPageInfoComponentProc gPageInfoCompProc;
//Max desc stuff necessary.
CLASS_DESC(plPageInfoComponent, gPageInfoDesc, "Page Info", "PageInfo", COMP_TYPE_MISC, PAGEINFO_CID)
//Max paramblock2 stuff below.
ParamBlockDesc2 gPageInfoCompBk
(
plComponent::kBlkComp, _T("PageInfo"), 0, &gPageInfoDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_PAGEINFO, IDS_COMP_PAGEINFOS, 0, 0, &gPageInfoCompProc,
plPageInfoComponent::kInfoAge, _T("ageName"), TYPE_STRING, 0, 0,
end,
plPageInfoComponent::kInfoPage, _T("pageName"), TYPE_STRING, 0, 0,
end,
plPageInfoComponent::kInfoSeqPrefix, _T("sequencePrefix"), TYPE_INT, 0, 0,
end,
plPageInfoComponent::kInfoSeqSuffix, _T("sequenceSuffix"), TYPE_INT, 0, 0,
end,
plPageInfoComponent::kRefVolatile_PageInfoUpdated, _T( "pageInfoUpdated" ), TYPE_BOOL, 0, 0,
p_default, 0,
end,
plPageInfoComponent::kItinerant, _T("itinerant"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_CHECK1,
end,
end
);
char plPageInfoComponent::fCurrExportedAge[ 256 ] = "";
plPageInfoComponent::plPageInfoComponent()
{
fSeqNumValidated = false;
fItinerant = false;
fClassDesc = &gPageInfoDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plPageInfoComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
// Another component already created a location, don't override it
if (pNode->GetRoomKey())
return false;
char *age = fCompPB->GetStr(kInfoAge);
char *room = fCompPB->GetStr(kInfoPage);
if (!age || *age == '\0' || !room || *room == '\0')
{
pErrMsg->Set(true,
"PageInfo Component Error",
"No Label for the Age, Chapter, or Page, on the Location component found on %s",
pNode->GetName()).Show();
return false;
}
// If we're only exporting a certain page, and this location isn't it, don't export this node
const char* exportPage = plConvert::Instance().GetConvertSettings()->fExportPage;
if (exportPage && stricmp(room, exportPage))
{
pNode->SetCanConvert(false);
return true;
}
// Check to make sure we don't try to export more than one age at a time
if( fCurrExportedAge[ 0 ] == 0 )
strncpy( fCurrExportedAge, age, sizeof( fCurrExportedAge ) );
else
{
if( stricmp( fCurrExportedAge, age ) != 0 )
{
// Our only currently accepted exception (eh?) is GlobalClothing and GlobalAvatars
if( ( stricmp( age, "GlobalAvatars" ) == 0 && stricmp( fCurrExportedAge, "GlobalClothing" ) == 0 ) ||
( stricmp( age, "GlobalClothing" ) == 0 && stricmp( fCurrExportedAge, "GlobalAvatars" ) == 0 ) )
{
}
else
{
pErrMsg->Set( true, "PageInfo Component Error",
"The scene you are trying to export is attempting to export to both ages %s and"
" %s. You are only allowed to export to one age at a time.",
fCurrExportedAge, age ).Show();
// Reset for next time
return false;
}
}
}
// Make sure our sequence partitions are up-to-date
IUpdateSeqNumbersFromAgeFile( pErrMsg );
// Need to re-get our age and page name here, since IUpdate() might change them
age = fCompPB->GetStr( kInfoAge );
room = fCompPB->GetStr( kInfoPage );
fItinerant = fCompPB->GetInt(kItinerant);
// Build our sequence number
Int32 newNum, seqNum;
seqNum = plPageInfoUtils::CombineSeqNum( fCompPB->GetInt( kInfoSeqPrefix ), fCompPB->GetInt( kInfoSeqSuffix ) );
newNum = plPluginResManager::ResMgr()->VerifySeqNumber( seqNum, age, room );
if( newNum != seqNum )
{
if( !fSeqNumValidated && seqNum != 0 )
{
// What error was it, exactly?
char errMsg[ 1024 ];
const plPageInfo *lastPage = plPluginResManager::ResMgr()->GetLastVerifyPage();
if( plPluginResManager::ResMgr()->GetLastVerifyError() == plPluginResManager::kErrRightPageWrongSeq )
{
sprintf( errMsg, "The Page Info component for %s>%s applied to object %s is attempting to export with a sequence number "
"different from what is already exported. Further, the already-exported page %s>%s has "
"the same sequence number as this Page Info component now. This is most likely due to the .age "
"files having been changed since the old page was exported. The recommended solution would be to "
"delete the offending page data and export both pages again.\n\n"
"The exporter has assigned a valid temporary sequence number for page %s>%s, but this data should not be used "
"for playing over the network or released for external use.\n\n"
"\t(Original sequence #: 0x%X)\n\t(Temporary sequence #: 0x%X)",
age, room, pNode->GetName(),
lastPage->GetAge(), lastPage->GetPage(), age, room, seqNum, newNum );
}
else if( plPluginResManager::ResMgr()->GetLastVerifyError() == plPluginResManager::kErrSeqAlreadyTaken )
{
sprintf( errMsg, "The Page Info component for %s>%s applied to object %s is attempting to export with "
"an identical sequence number to the already-exported page %s>%s. This is usually due to "
"either page having been exported with an invalid or missing .age file. Please verify that both "
"pages have valid .age files and their sequence numbers do not conflict in the Age Description "
"Manager.\n\n"
"The exporter has assigned a valid temporary sequence number for page %s>%s, but this data should not be used "
"for playing over the network or released for external use.\n\n"
"\t(Original sequence #: 0x%X)\n\t(Temporary sequence #: 0x%X)",
age, room, pNode->GetName(),
lastPage->GetAge(), lastPage->GetPage(), age, room, seqNum, newNum );
}
else if( plPluginResManager::ResMgr()->GetLastVerifyError() == plPluginResManager::kErrCantFindValid )
{
sprintf( errMsg, "The Page Info component for %s>%s applied to object %s is attempting to export with "
"an invalid sequence number. The exporter could not find a valid, free sequence number to use, so this "
"page cannot be exported. Contact mcn (ext 264) immediately!\n\n"
"\t(Original sequence #: 0x%X)",
age, room, pNode->GetName(), seqNum );
pErrMsg->Set( true, "PageInfo Convert Error", errMsg ).Show();
return false;
}
else
{
sprintf( errMsg, "The Page Info component for %s>%s applied to object %s is attempting to export with "
"a sequence number that is invalid for an unknown reason.\n\n"
"The exporter has assigned a valid temporary sequence number, but this data should not be used "
"for playing over the network or released for external use.\n\n"
"\t(Original sequence #: 0x%X)\n\t(Temporary sequence #: 0x%X)",
age, room, pNode->GetName(), seqNum, newNum );
}
pErrMsg->Set( true, "PageInfo Convert Error", errMsg ).Show();
pErrMsg->Set( false );
fSeqNumValidated = true;
}
seqNum = newNum;
}
if (fItinerant)
int i = 0;
plKey roomKey = plPluginResManager::ResMgr()->NameToLoc(age, room, seqNum, fItinerant );
if(!roomKey)
{
pErrMsg->Set(true,
"PageInfo Convert Error",
"Location Component %s has a Missing Location. Nuke the files in the dat directory and re-export.",
pNode->GetName()).Show();
return false;
}
pNode->SetRoomKey(roomKey);
if (!strcmp(age, "GlobalClothing"))
((plSceneNode *)roomKey->GetObjectPtr())->SetFilterGenericsOnly(true);
return true;
}
hsBool plPageInfoComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
// Make sure we clear this flag so that the next time around it's clear
fCompPB->SetValue( kRefVolatile_PageInfoUpdated, 0, (int)false );
fSeqNumValidated = false;
return true;
}
hsBool plPageInfoComponent::DeInit(plMaxNode *node, plErrorMsg *pErrMsg)
{
plKey snKey = node->GetRoomKey();
plSceneObject *so = node->GetSceneObject();
if(so)
{
if (node->GetSwappableGeom())
{
snKey->Release(so->GetKey());
node->GetMaxNodeData()->SetSceneObject(nil);
// Since child refs are now passive, this isn't needed.
/*
plMaxNode *parent = (plMaxNode *)node->GetParentNode();
if (!parent->IsRootNode() && !parent->GetSwappableGeom())
{
parent->GetSceneObject()->GetKey()->Release(so->GetKey());
}
*/
}
}
return true;
}
char *plPageInfoComponent::GetAgeName()
{
return fCompPB->GetStr(ParamID(kInfoAge));
}
//// IVerifyLatestAgeAsset ///////////////////////////////////////////////////
// Checks in assetMan to make sure we have the latest .age file to export
// with.
void plPageInfoComponent::IVerifyLatestAgeAsset( const char *ageName, const char *localPath, plErrorMsg *errMsg )
{
char ageFileName[ MAX_PATH ], assetPath[ MAX_PATH ];
MaxAssInterface *assetMan = GetMaxAssInterface();
if( assetMan == nil )
return; // No AssetMan available
// Try to find it in assetMan
sprintf( ageFileName, "%s.age", ageName );
jvUniqueId assetId;
if (assetMan->FindAssetByFilename(ageFileName, assetId))
{
// Get the latest version
if (!assetMan->GetLatestVersionFile(assetId, assetPath, sizeof(assetPath)))
{
errMsg->Set( true, "PageInfo Convert Error",
"Unable to update age file for '%s' because AssetMan was unable to get the latest version. Using local copy instead.", ageName ).Show();
errMsg->Set( false );
return;
}
// Got the latest version, just copy over and roll!
plFileUtils::RemoveFile( localPath );
plFileUtils::FileCopy( assetPath, localPath );
}
else
{
// Not found, so just assume it's a local one (no error)
}
}
//// IUpdateSeqNumbersFromAgeFile ////////////////////////////////////////////
// With the new sequence numbers, it's vital that our sequence numbers that
// we use to export are synched up with the latest .age files. This function
// makes sure that we're synched before we start using 'em.
void plPageInfoComponent::IUpdateSeqNumbersFromAgeFile( plErrorMsg *errMsg )
{
// Check to see if we've updated already
if( fCompPB->GetInt( kRefVolatile_PageInfoUpdated ) )
return; // Already updated this pass!
// Mark us as updated
fCompPB->SetValue( kRefVolatile_PageInfoUpdated, 0, (int)true );
char path[MAX_PATH];
const char *ageFolder = plPageInfoUtils::GetAgeFolder();
if( ageFolder == nil )
{
errMsg->Set( true,
"PageInfo Convert Error",
"There was a problem converting the PageInfo Component %s (the age folder couldn't be located). "
"The exporter will assign a temporary sequence number to this page, but you'll be lucky if it works at all.",
GetINode()->GetName() ).Show();
errMsg->Set( false );
fCompPB->SetValue( kInfoSeqPrefix, 0, 0 );
fCompPB->SetValue( kInfoSeqSuffix, 0, 0 );
return;
}
const char *curAge = fCompPB->GetStr( kInfoAge );
if( !curAge || *curAge == '\0' )
{
errMsg->Set( true,
"PageInfo Convert Error",
"There was a problem converting the PageInfo Component %s (no age name was selected). "
"The exporter will assign a temporary sequence number to this page, but you'll be lucky if it works at all.",
GetINode()->GetName()).Show();
errMsg->Set( false );
fCompPB->SetValue( kInfoSeqPrefix, 0, 0 );
fCompPB->SetValue( kInfoSeqSuffix, 0, 0 );
return;
}
sprintf(path, "%s%s.age", ageFolder, curAge);
IVerifyLatestAgeAsset( curAge, path, errMsg );
hsUNIXStream s;
if (!s.Open(path))
{
errMsg->Set( true,
"PageInfo Convert Error",
"There was a problem converting the PageInfo Component %s (the age name \"%s\" is invalid). "
"The exporter will assign a temporary sequence number to this page, but you'll be lucky if it works at all.",
GetINode()->GetName(), curAge ).Show();
errMsg->Set( false );
fCompPB->SetValue( kInfoSeqPrefix, 0, 0 );
fCompPB->SetValue( kInfoSeqSuffix, 0, 0 );
return;
}
// create and read the age desc
plAgeDescription aged;
aged.Read(&s);
s.Close();
// Update based on the age file now
fCompPB->SetValue( kInfoSeqPrefix, 0, (int)aged.GetSequencePrefix() );
// Find our page
const char *compPBPageName = fCompPB->GetStr( kInfoPage );
if( compPBPageName == nil )
{
errMsg->Set( true,
"PageInfo Convert Error",
"There was a problem converting the PageInfo Component %s (no page name was specified). "
"The exporter will assign a temporary sequence number to this page, but you'll be lucky if it works at all.",
GetINode()->GetName() ).Show();
errMsg->Set( false );
fCompPB->SetValue( kInfoSeqPrefix, 0, 0 );
fCompPB->SetValue( kInfoSeqSuffix, 0, 0 );
return;
}
plAgePage *page;
aged.SeekFirstPage();
while( ( page = aged.GetNextPage() ) != nil )
{
if( stricmp( page->GetName(), compPBPageName ) == 0 )
{
fCompPB->SetValue( kInfoSeqSuffix, 0, (int)page->GetSeqSuffix() );
// Also re-copy the page name, just to make sure the case is correct
fCompPB->SetValue( kInfoPage, 0, (char *)page->GetName() );
return;
}
}
// If we got here, the page name is invalid
char msg[ 512 ];
sprintf( msg, "There was a problem converting the PageInfo Component %s (the page \"%s\" wasn't found in the age file for age \"%s\"). "
"The exporter will assign a temporary sequence number to this page, but you'll be lucky if it works at all.",
GetINode()->GetName(), compPBPageName, curAge );
errMsg->Set( true, "PageInfo Convert Error", msg ).Show();
errMsg->Set( false );
fCompPB->SetValue( kInfoSeqPrefix, 0, 0 );
fCompPB->SetValue( kInfoSeqSuffix, 0, 0 );
}
const char *plPageInfoUtils::GetAgeFolder()
{
static char ageFolder[MAX_PATH];
static bool initialized = false;
if (!initialized)
{
initialized = true;
ageFolder[0] = '\0';
const char *plasmaPath = plMaxConfig::GetClientPath();
if (!plasmaPath)
return nil;
strcpy(ageFolder, plasmaPath);
strcat(ageFolder, plAgeDescription::kAgeDescPath);
}
if (ageFolder[0] != '\0')
return ageFolder;
else
return nil;
}
Int32 plPageInfoUtils::CombineSeqNum( int prefix, int suffix )
{
hsAssert(abs(prefix) < 0xFF, "Sequence prefix must be less then the max 8-bit number");
hsAssert(suffix <= 0xFFFF, "Sequence suffix must be less then the max 16-bit number");
hsAssert(suffix >= 0, "Sequence suffix must be unsigned");
if( prefix < 0 )
return -( ( ( -prefix ) << 16 ) + suffix );
else
return ( prefix << 16 ) + suffix;
}
Int32 plPageInfoUtils::GetCommonSeqNumFromNormal( Int32 normalSeqNumber, int whichCommonPage )
{
int prefix;
const int kFirstCommonSeqSuffix = 0xffff;
hsAssert( whichCommonPage < plAgeDescription::kNumCommonPages, "Invalid common page index in GetCommonSeqNumFromNormal()" );
if( normalSeqNumber < 0 )
{
prefix = -( (-normalSeqNumber) >> 16 );
}
else
prefix = normalSeqNumber >> 16;
return CombineSeqNum( prefix, kFirstCommonSeqSuffix - whichCommonPage );
}
Int32 plPageInfoUtils::GetSeqNumFromAgeDesc( const char *ageName, const char *pageName )
{
int seqPrefix, seqSuffix = 0;
plAgeDescription *aged = GetAgeDesc( ageName );
if( aged == nil )
{
// ???? This ain't good...attempt to get the resMgr to give us a temporary seqNum...
return 0;
}
seqPrefix = aged->GetSequencePrefix();
// Find our page
plAgePage *page;
aged->SeekFirstPage();
while( ( page = aged->GetNextPage() ) != nil )
{
if( stricmp( pageName, page->GetName() ) == 0 )
{
seqSuffix = page->GetSeqSuffix();
break;
}
}
delete aged;
return CombineSeqNum( seqPrefix, seqSuffix );
}
plAgeDescription *plPageInfoUtils::GetAgeDesc( const char *ageName )
{
char path[ MAX_PATH ];
const char *ageFolder = plPageInfoUtils::GetAgeFolder();
if( ageFolder == nil || ageName == nil )
return nil;
sprintf( path, "%s%s.age", ageFolder, ageName );
hsUNIXStream s;
if( !s.Open( path ) )
return nil;
// Create and read the age desc
plAgeDescription *aged = TRACKED_NEW plAgeDescription;
aged->Read( &s );
s.Close();
return aged;
}
const char* LocCompGetPage(plComponentBase* comp)
{
if (!comp)
return nil;
const char* page = nil;
if (comp->ClassID() == PAGEINFO_CID)
{
IParamBlock2* pb = comp->GetParamBlockByID(plComponentBase::kBlkComp);
page = pb->GetStr(plPageInfoComponent::kInfoPage);
}
if (page && *page != '\0')
return page;
return nil;
}
static char *CheckPageInfoCompsRecur(plMaxNode *node)
{
plComponentBase *comp = node->ConvertToComponent();
if (comp && comp->ClassID() == PAGEINFO_CID)
{
plPageInfoComponent* pageComp = (plPageInfoComponent*)comp;
return pageComp->GetAgeName();
}
for (int i = 0; i < node->NumberOfChildren(); i++)
{
char *result = CheckPageInfoCompsRecur((plMaxNode*)node->GetChildNode(i));
if (result)
return result;
}
return nil;
}
void plPageInfoComponent::NotifyProc(void *param, NotifyInfo *info)
{
if (info->intcode == NOTIFY_FILE_POST_OPEN)
{
char *ageName = CheckPageInfoCompsRecur((plMaxNode*)GetCOREInterface()->GetRootNode());
if (ageName != nil)
strncpy( fCurrExportedAge, ageName, sizeof( fCurrExportedAge ) );
}
else if (info->intcode == NOTIFY_SYSTEM_POST_RESET ||
info->intcode == NOTIFY_SYSTEM_POST_NEW)
{
fCurrExportedAge[0] = 0;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Room Component
//
//
class plRoomComponent : public plComponent
{
public:
plRoomComponent();
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary.
OBSOLETE_CLASS_DESC(plRoomComponent, gRoomDesc, "Location", "Location", COMP_TYPE_MISC, ROOM_CID)
enum
{
kLocRoom,
kLocAge,
kLocDistrict,
kLocSeqNumber
};
//Max paramblock2 stuff below.
ParamBlockDesc2 gRoomCompBk
(
1, _T("Location"), 0, &gRoomDesc, P_AUTO_CONSTRUCT+ P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_ROOM, IDS_COMP_ROOMS, 0, 0, NULL,
// params
kLocAge, _T("Age"), TYPE_STRING, 0, 0,
p_ui, TYPE_EDITBOX, IDC_COMP_ROOM_AGE_TEXTBOX,
end,
kLocDistrict, _T("District"), TYPE_STRING, 0, 0,
p_ui, TYPE_EDITBOX, IDC_COMP_ROOM_DISTRICT_TEXTBOX,
end,
kLocRoom, _T("Room"), TYPE_STRING, 0, 0,
p_ui, TYPE_EDITBOX, IDC_COMP_ROOM_ROOM_TEXTBOX,
end,
kLocSeqNumber, _T("seqNumber"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_POS_INT, IDC_ROOM_SEQEDIT, IDC_ROOM_SEQSPIN, SPIN_AUTOSCALE,
end,
end
);
plRoomComponent::plRoomComponent()
{
fClassDesc = &gRoomDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plRoomComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// View Facing Component
//
//
//Class that accesses the paramblock below.
class plViewFacingComponent : public plComponent
{
public:
plViewFacingComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary below.
CLASS_DESC(plViewFacingComponent, gViewFacingDesc, "Billboard", "Billboard", COMP_TYPE_GRAPHICS, Class_ID(0x7fab4d1f, 0x30f95438))
//
// Block not necessary, kept for backwards compat.
//
enum
{
kTypeofView, kViewFaceScaleX, kViewFaceScaleY, kViewFaceScaleZ
};
ParamBlockDesc2 gViewFacingBk
( // KLUDGE: not the defined block ID, but kept for backwards compat.
1, _T("View Facing"), 0, &gViewFacingDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp,
#if 0
IDD_COMP_VIEWFACE, IDS_COMP_VIEWFACES, 0, 0, NULL,
kTypeofView, _T("ViewType"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_RADIO_VF1, IDC_RADIO_VF2, IDC_RADIO_VF3, IDC_RADIO_VF4,
end,
kViewFaceScaleX, _T("ViewFaceScaleX"), TYPE_FLOAT, 0, 0,
p_default, 0.0f,
p_range, 0.0, 1500.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
IDC_COMP_VFSCALE_EDIT1, IDC_COMP_VFSCALE_SPIN1, 0.1f,
end,
kViewFaceScaleY, _T("ViewFaceScaleY"), TYPE_FLOAT, 0, 0,
p_default, 0.0f,
p_range, 0.0, 1500.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
IDC_COMP_VFSCALE_EDIT2, IDC_COMP_VFSCALE_SPIN2, 0.1f,
end,
kViewFaceScaleZ, _T("ViewFaceScaleZ"), TYPE_FLOAT, 0, 0,
p_default, 0.0f,
p_range, 0.0, 1500.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
IDC_COMP_VFSCALE_EDIT3, IDC_COMP_VFSCALE_SPIN3, 0.1f,
end,
#endif
end
);
plViewFacingComponent::plViewFacingComponent()
{
fClassDesc = &gViewFacingDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
static hsBool NodeHasTMAnimation(plMaxNode* node)
{
if( node->GetUnBounded() )
return true;
plPhysicalProps* props = node->GetPhysicalProps();
if( props && props->IsUsed() )
{
if( (props->GetMass() > 0) && !props->GetPinned() )
return true;
}
return node->GetTMController() && node->GetTMController()->IsAnimated();
}
static hsBool FindTMAnimatedChildrenRecur(plMaxNode* node)
{
if( !node->CanConvert() )
return false;
if( NodeHasTMAnimation(node) )
return true;
int i;
for( i = 0; i < node->NumChildren(); i++ )
{
if( FindTMAnimatedChildrenRecur((plMaxNode*)node->GetChildNode(i)) )
return true;
}
return false;
}
static void FindRecursiveBounds(plMaxNode* node, hsBounds3Ext& bnd)
{
if( !node->CanConvert() )
return;
int i;
for( i = 0; i < node->NumChildren(); i++ )
{
FindRecursiveBounds((plMaxNode*)node->GetChildNode(i), bnd);
}
const TimeValue currTime(0);
Object *obj = node->EvalWorldState(currTime).obj;
if( !obj )
return;
if( obj->CanConvertToType(triObjectClassID) )
{
TriObject *meshObj = (TriObject *)obj->ConvertToType(currTime, triObjectClassID);
if( !meshObj )
return;
Matrix3 l2w = node->GetObjectTM(currTime);
Box3 box = meshObj->mesh.getBoundingBox(&l2w);
if( !box.IsEmpty() )
{
bnd.Union(&hsPoint3(box.Min().x, box.Min().y, box.Min().z));
bnd.Union(&hsPoint3(box.Max().x, box.Max().y, box.Max().z));
}
if( meshObj != obj )
meshObj->DeleteThis();
}
return;
}
static hsBool FindMaxBounds(plMaxNode* node, hsBounds3Ext& bnd)
{
bnd.MakeEmpty();
// First, look from the node up to the root. If anything is animated, we can't do this.
plMaxNode* parent = node;
while( !parent->IsRootNode() )
{
// We shouldn't ever hit this, but whatever.
if( !parent->CanConvert() )
return false;
if( NodeHasTMAnimation(parent) )
return false;
parent = (plMaxNode*)parent->GetParentNode();
}
// Second, look down the children. If any of them are animated, we can't do this.
if( FindTMAnimatedChildrenRecur(node) )
return false;
// Now find the recursive world space bounds of us and all our children.
FindRecursiveBounds(node, bnd);
// Translate to local about our pivot
hsMatrix44 l2w = node->GetLocalToWorld44();
// Expand them to be symmetric about local origin.
bnd.MakeSymmetric(&l2w.GetTranslate());
return true;
}
hsBool plViewFacingComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
plViewFaceModifier* pMod = TRACKED_NEW plViewFaceModifier;
hsBounds3Ext maxBnd;
if( FindMaxBounds(node, maxBnd) )
pMod->SetMaxBounds(maxBnd);
// int ChosenType = fCompPB->GetInt(kTypeofView);
// switch(ChosenType)
// {
// case 0:
// pMod->SetFlag(plViewFaceModifier::kPivotFace);
// break;
// case 1:
// pMod->SetFlag(plViewFaceModifier::kPivotFavorY);
// break;
// case 2:
pMod->SetFlag(plViewFaceModifier::kPivotY);
// break;
// case 3:
// pMod->SetFlag(plViewFaceModifier::kPivotTumble);
// break;
// }
#if 0
if(fCompPB->GetFloat(kViewFaceScaleX) || fCompPB->GetFloat(kViewFaceScaleY) || fCompPB->GetFloat(kViewFaceScaleZ))
{
pMod->SetFlag(plViewFaceModifier::kScale);
hsVector3 scale;
scale.Set(1.f, 1.f, 1.f);
scale.fX = fCompPB->GetFloat(kViewFaceScaleX);
scale.fY = fCompPB->GetFloat(kViewFaceScaleY);
scale.fZ = fCompPB->GetFloat(kViewFaceScaleZ);
pMod->SetScale(scale);
}
#endif
pMod->SetOrigTransform(node->GetLocalToParent44(), node->GetParentToLocal44());
node->AddModifier(pMod, IGetUniqueName(node));
return true;
}
hsBool plViewFacingComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
pNode->SetForceLocal(true);
pNode->SetMovable(true);
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Sprite Component
//
//
//Class that accesses the paramblock below.
class plSpriteComponent : public plComponent
{
public:
plSpriteComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary below.
CLASS_DESC(plSpriteComponent, gSpriteDesc, "Sprite", "Sprite", COMP_TYPE_GRAPHICS, Class_ID(0x1e18192b, 0x312f579b))
//
// Block not necessary, kept for backwards compat.
//
ParamBlockDesc2 gSpriteBk
( // KLUDGE: not the defined block ID, but kept for backwards compat.
1, _T("Sprite"), 0, &gSpriteDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp,
end
);
plSpriteComponent::plSpriteComponent()
{
fClassDesc = &gSpriteDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plSpriteComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
plViewFaceModifier* pMod = TRACKED_NEW plViewFaceModifier;
hsBounds3Ext maxBnd;
if( FindMaxBounds(node, maxBnd) )
pMod->SetMaxBounds(maxBnd);
pMod->SetFlag(plViewFaceModifier::kPivotFace);
pMod->SetOrigTransform(node->GetLocalToParent44(), node->GetParentToLocal44());
node->AddModifier(pMod, IGetUniqueName(node));
return true;
}
hsBool plSpriteComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
pNode->SetForceLocal(true);
pNode->SetMovable(true);
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Occlusion Component
//
//
enum {
kOccTwoSidedChekbox
};
class plOcclusionComponentProc : 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 (LOWORD(wParam) == IDC_COMP_OCCLUSION_CKBX)
{
return true;
}
}
}
return false;
}
void DeleteThis() {}
};
static plOcclusionComponentProc gOccProc;
//Class that accesses the paramblock below.
class plOcclusionComponent : public plComponent
{
public:
plOcclusionComponent();
virtual hsBool SetupProperties(plMaxNode* pNode, plErrorMsg* pErrMsg);
virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
virtual hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);
virtual void CollectNonDrawables(INodeTab& nonDrawables) { AddTargetsToList(nonDrawables); }
};
CLASS_DESC(plOcclusionComponent, gOcclusionDesc, "Occlusion", "Occlusion", COMP_TYPE_GRAPHICS, Class_ID(0x18c454df, 0x1ecd40f5))
ParamBlockDesc2 gOcclusionBk
(
plComponent::kBlkComp, _T("Occlusion"), 0, &gOcclusionDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_OCCLUSION, IDS_COMP_OCCLUSIONS, 0, 0, &gOccProc,
kOccTwoSidedChekbox, _T("TwoSided"), TYPE_BOOL, 0, 0,
p_default, FALSE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_OCCLUSION_CKBX,
end,
end
);
plOcclusionComponent::plOcclusionComponent()
{
fClassDesc = &gOcclusionDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plOcclusionComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
return true;
}
hsBool plOcclusionComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
hsBool twoSided = fCompPB->GetInt(kOccTwoSidedChekbox);
hsBool isHole = false;
return node->ConvertToOccluder(pErrMsg, twoSided, isHole);
}
hsBool plOcclusionComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
pNode->SetDrawable(false);
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// CamView Component
//
//
//Class that accesses the paramblock below.
class plCamViewComponent : public plComponent
{
hsBool fBogus;
void IMakeEveryoneOpaqueRecur(plMaxNode* node);
void IMakeEveryoneOpaque(plMaxNode* node);
public:
plCamViewComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool PreConvert(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary below.
CLASS_DESC(plCamViewComponent, gCamViewDesc, "Camera View", "CamView", COMP_TYPE_GRAPHICS, Class_ID(0x5e9f0243, 0xe7f2c08))
enum
{
kWhateverCheckBox
};
ParamBlockDesc2 gCamViewBk
(
plComponent::kBlkComp, _T("CamView"), 0, &gCamViewDesc, P_AUTO_CONSTRUCT/* + P_AUTO_UI*/, plComponent::kRefComp,
// IDD_COMP_CAMVIEW, IDS_COMP_CAMVIEWS, 0, 0, NULL,
end
);
plCamViewComponent::plCamViewComponent()
: fBogus(false)
{
fClassDesc = &gCamViewDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plCamViewComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
TimeValue timeVal(0);
Object* obj = node->EvalWorldState(timeVal).obj;
GenCamera* cam = nil;
if( obj->CanConvertToType(Class_ID(LOOKAT_CAM_CLASS_ID, 0)) )
cam = (GenCamera *) obj->ConvertToType(timeVal, Class_ID(LOOKAT_CAM_CLASS_ID, 0));
else
if( obj->CanConvertToType(Class_ID(SIMPLE_CAM_CLASS_ID, 0)) )
cam = (GenCamera *) obj->ConvertToType(timeVal, Class_ID(SIMPLE_CAM_CLASS_ID, 0));
if( !cam )
{
hsAssert(false, "Should have checked for the camera in PreConvert");
return false;
}
plPostEffectMod* mod = TRACKED_NEW plPostEffectMod;
float hither = cam->GetEnvRange(timeVal, ENV_NEAR_RANGE);
if( hither < 0.5f )
hither = 0.5f;
float yon = cam->GetEnvRange(timeVal, ENV_FAR_RANGE);
mod->SetHither(hither);
mod->SetYon(yon);
// radians
float fov = cam->GetFOV(timeVal);
// convert
int FOVType = cam->GetFOVType();
hsScalar fovX, fovY;
switch(FOVType)
{
case 0: // FOV_W
{
fovX = fov;
fovY = fovX *3.f / 4.f;
}
break;
case 1: // FOV_H
{
fovY = fov;
fovX = fovY * 4.f / 3.f;
}
break;
}
fovX *= 180.f / hsScalarPI;
fovY *= 180.f / hsScalarPI;
mod->SetFovX(fovX);
mod->SetFovY(fovY);
plKey sceneNodeKey = node->GetRoomKey();
mod->SetNodeKey(sceneNodeKey);
node->AddModifier(mod, IGetUniqueName(node));
return true;
}
hsBool plCamViewComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
TimeValue timeVal(0);
Object* obj = node->EvalWorldState(timeVal).obj;
if( obj->CanConvertToType(Class_ID(LOOKAT_CAM_CLASS_ID, 0))
|| obj->CanConvertToType(Class_ID(SIMPLE_CAM_CLASS_ID, 0)) )
fBogus = false;
else
fBogus = true;
if( fBogus )
pErrMsg->Set(true, node->GetName(), "CamView component attached to non-camera").CheckAndAsk();
if( !fBogus )
IMakeEveryoneOpaque(node);
return true;
}
void plCamViewComponent::IMakeEveryoneOpaque(plMaxNode* node)
{
plMaxNode* root = (plMaxNode *)node->GetInterface()->GetRootNode();
int i;
for( i = 0; i < root->NumberOfChildren(); i++ )
IMakeEveryoneOpaqueRecur((plMaxNode*)(root->GetChildNode(i)));
}
void plCamViewComponent::IMakeEveryoneOpaqueRecur(plMaxNode* node)
{
if( node->CanConvert() )
{
node->SetNoSpanReSort(true);
node->SetNoSpanSort(true);
int i;
for( i = 0; i < node->NumberOfChildren(); i++ )
{
IMakeEveryoneOpaqueRecur((plMaxNode *)(node->GetChildNode(i)));
}
}
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plCamViewComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
node->SetForceLocal(true);
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Follow Component
//
//
enum
{
kAffectX,
kLeaderTypeRadio,
kLeaderObjectSel,
kAffectY,
kAffectZ,
kAffectRotate
};
// 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 plLeaderObjAccessor : public PBAccessor
{
public:
void Set(PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t)
{
if( (id == kLeaderObjectSel) )
{
plComponentBase *comp = (plComponentBase*)owner;
comp->NotifyDependents(FOREVER, PART_ALL, REFMSG_USER_COMP_REF_CHANGED);
}
}
};
plLeaderObjAccessor gLeaderObjAccessor;
class plFollowComponentProc : 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(kLeaderObjectSel, TRUE, "Press the button, & select the object to follow in one of the Viewports" );
if( pb->GetInt(kLeaderTypeRadio) == Int32(plFollowMod::kObject) )
map->Enable(kLeaderObjectSel, TRUE);
else
map->Enable(kLeaderObjectSel, FALSE);
}
return true;
//////////////////
case WM_COMMAND:
{
if( (LOWORD(wParam) == IDC_F_RADIO_PLAYER)
||(LOWORD(wParam) == IDC_F_RADIO_LISTENER)
|| (LOWORD(wParam) == IDC_F_RADIO_CAMERA)
|| (LOWORD(wParam) == IDC_F_RADIO_OBJECT) )
{
IParamBlock2 *pb = map->GetParamBlock();
if( pb->GetInt(kLeaderTypeRadio) == Int32(plFollowMod::kObject) )
map->Enable(kLeaderObjectSel, TRUE);
else
map->Enable(kLeaderObjectSel, FALSE);
return true;
}
}
}
return false;
}
void DeleteThis() {}
};
static plFollowComponentProc gFollowProc;
//Class that accesses the paramblock below.
class plFollowComponent : public plComponent
{
private:
hsBool fValid;
plFollowMod* IMakeFollowMod(plMaxNode* pNode, plErrorMsg* pErrMsg);
public:
plFollowComponent();
hsBool SetupProperties(plMaxNode* pNode, plErrorMsg* pErrMsg);
hsBool PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
CLASS_DESC(plFollowComponent, gFollowDesc, "Follow", "Follow", COMP_TYPE_GRAPHICS, Class_ID(0x44262418, 0x73ee145b))
ParamBlockDesc2 gFollowBk
(
plComponent::kBlkComp, _T("Follow"), 0, &gFollowDesc, P_AUTO_CONSTRUCT+P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FOLLOW, IDS_COMP_FOLLOWS, 0, 0, &gFollowProc,
kAffectX, _T("X"), TYPE_BOOL, 0, 0,
p_default, TRUE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_FOLLOW_X,
end,
kAffectY, _T("Y"), TYPE_BOOL, 0, 0,
p_default, TRUE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_FOLLOW_Y,
end,
kAffectZ, _T("Z"), TYPE_BOOL, 0, 0,
p_default, TRUE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_FOLLOW_Z,
end,
kAffectRotate, _T("Rotate"), TYPE_BOOL, 0, 0,
p_default, FALSE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_FOLLOW_ROTATE,
end,
kLeaderTypeRadio, _T("LeaderType"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 4, IDC_F_RADIO_PLAYER, IDC_F_RADIO_CAMERA, IDC_F_RADIO_LISTENER, IDC_F_RADIO_OBJECT,
p_vals, plFollowMod::kLocalPlayer, plFollowMod::kCamera, plFollowMod::kListener, plFollowMod::kObject,
p_default, plFollowMod::kLocalPlayer,
end,
kLeaderObjectSel, _T("ObjectChoice"), TYPE_INODE, 0, 0,
p_ui, TYPE_PICKNODEBUTTON, IDC_COMP_FOLLOW_CHOOSE_OBJECT,
p_prompt, IDS_COMP_LINE_CHOSE_OBJECT,
p_accessor, &gLeaderObjAccessor,
end,
end
);
plFollowComponent::plFollowComponent()
: fValid(false)
{
fClassDesc = &gFollowDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
plFollowMod* plFollowComponent::IMakeFollowMod(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
plFollowMod::FollowLeaderType lType = plFollowMod::FollowLeaderType(fCompPB->GetInt(kLeaderTypeRadio));
plFollowMod* follow = TRACKED_NEW plFollowMod;
hsgResMgr::ResMgr()->NewKey(IGetUniqueName(pNode), follow, pNode->GetLocation());
if( plFollowMod::kObject == lType )
{
if(fCompPB->GetINode(kLeaderObjectSel) != NULL)
{
plMaxNode* targNode = (plMaxNode*)fCompPB->GetINode(kLeaderObjectSel);
if( targNode->CanConvert() )
{
plSceneObject* targObj = targNode->GetSceneObject();
if( targObj )
{
plGenRefMsg* refMsg = TRACKED_NEW plGenRefMsg(follow->GetKey(), plRefMsg::kOnCreate, 0, plFollowMod::kRefLeader);
hsgResMgr::ResMgr()->AddViaNotify(targObj->GetKey(), refMsg, plRefFlags::kPassiveRef);
follow->SetType(plFollowMod::kObject);
}
}
}
}
else
{
follow->SetType(lType);
}
UInt32 mode = 0;
if( fCompPB->GetInt(kAffectX) )
mode |= plFollowMod::kPositionX;
if( fCompPB->GetInt(kAffectY) )
mode |= plFollowMod::kPositionY;
if( fCompPB->GetInt(kAffectZ) )
mode |= plFollowMod::kPositionZ;
if( fCompPB->GetInt(kAffectRotate) )
mode |= plFollowMod::kRotate;
if( !mode )
mode = plFollowMod::kFullTransform;
follow->SetMode(mode);
return follow;
}
hsBool plFollowComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
if( !fValid )
return true;
plFollowMod* follow = IMakeFollowMod(node, pErrMsg);
if( follow )
node->AddModifier(follow, IGetUniqueName(node));
return true;
}
hsBool plFollowComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
fValid = false;
if( plFollowMod::kObject == fCompPB->GetInt(kLeaderTypeRadio) )
{
if( !fCompPB->GetINode(kLeaderObjectSel) )
{
return true;
}
}
fValid = true;
pNode->SetForceLocal(true);
pNode->SetMovable(true);
return true;
}
hsBool plFollowComponent::PreConvert(plMaxNode* pNode, plErrorMsg* pErrMsg)
{
if( !fValid )
return true;
fValid = false;
if( plFollowMod::kObject == fCompPB->GetInt(kLeaderTypeRadio) )
{
plMaxNode* followNode = (plMaxNode*)fCompPB->GetINode(kLeaderObjectSel);
if( !followNode->CanConvert() )
{
return true;
}
}
fValid = true;
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Unleash Component
//
//
//Class that accesses the paramblock below.
class plUnleashComponent : public plComponent
{
public:
plUnleashComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};
//Max desc stuff necessary below.
CLASS_DESC(plUnleashComponent, gUnleashDesc, "Unleash Satan", "UnleashSatan", COMP_TYPE_GRAPHICS, Class_ID(0x5d937fa8, 0x1001411a))
ParamBlockDesc2 gUnleashBk
(
plComponent::kBlkComp, _T("Unleash"), 0, &gUnleashDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_UNLEASH, IDS_COMP_UNLEASH, 0, 0, NULL,
end
);
plUnleashComponent::plUnleashComponent()
{
fClassDesc = &gUnleashDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plUnleashComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
pNode->SetRunTimeLight(true);
pNode->SetForcePreShade(true);
return true;
}
hsBool plUnleashComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// ForceRTLight Component
//
//
//Class that accesses the paramblock below.
class plForceRTLightComponent : public plComponent
{
public:
plForceRTLightComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; }
};
//Max desc stuff necessary below.
CLASS_DESC(plForceRTLightComponent, gForceRTLightDesc, "Force RT Light", "ForceRTLight", COMP_TYPE_GRAPHICS, Class_ID(0x1485091b, 0x42852fb5))
ParamBlockDesc2 gForceRTLightBk
(
plComponent::kBlkComp, _T("ForceRTLight"), 0, &gForceRTLightDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_FORCE_RTLIGHT, IDS_COMP_FORCE_RTLIGHT, 0, 0, NULL,
end
);
plForceRTLightComponent::plForceRTLightComponent()
{
fClassDesc = &gForceRTLightDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plForceRTLightComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
pNode->SetRunTimeLight(true);
pNode->SetNoPreShade(true);
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Terrain Optimise Component (currently just dices).
//
//
//Class that accesses the paramblock below.
class plGeoDiceComponent : public plComponent
{
public:
enum {
kActive,
kMaxFaces,
kMaxSize,
kMinFaces,
kOverride
};
public:
plGeoDiceComponent();
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; }
};
static const int kDefMaxFaces(1000);
static const float kDefMaxSize(250.f);
static const int kDefMinFaces(300);
class plGeoDiceComponentProc : 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(plGeoDiceComponent::kOverride) )
{
pb->SetValue(plGeoDiceComponent::kMaxFaces, t, kDefMaxFaces);
pb->SetValue(plGeoDiceComponent::kMaxSize, t, kDefMaxSize);
pb->SetValue(plGeoDiceComponent::kMinFaces, t, kDefMinFaces);
map->Enable(plGeoDiceComponent::kMaxFaces, FALSE);
map->Enable(plGeoDiceComponent::kMaxSize, FALSE);
map->Enable(plGeoDiceComponent::kMinFaces, FALSE);
}
else
{
map->Enable(plGeoDiceComponent::kMaxFaces, TRUE);
map->Enable(plGeoDiceComponent::kMaxSize, TRUE);
map->Enable(plGeoDiceComponent::kMinFaces, TRUE);
}
}
return true;
//////////////////
case WM_COMMAND:
{
if( LOWORD(wParam) == IDC_COMP_GEO_DICE_OVERRIDE )
{
IParamBlock2 *pb = map->GetParamBlock();
if( !pb->GetInt(plGeoDiceComponent::kOverride) )
{
pb->SetValue(plGeoDiceComponent::kMaxFaces, t, kDefMaxFaces);
pb->SetValue(plGeoDiceComponent::kMaxSize, t, kDefMaxSize);
pb->SetValue(plGeoDiceComponent::kMinFaces, t, kDefMinFaces);
map->Enable(plGeoDiceComponent::kMaxFaces, FALSE);
map->Enable(plGeoDiceComponent::kMaxSize, FALSE);
map->Enable(plGeoDiceComponent::kMinFaces, FALSE);
}
else
{
map->Enable(plGeoDiceComponent::kMaxFaces, TRUE);
map->Enable(plGeoDiceComponent::kMaxSize, TRUE);
map->Enable(plGeoDiceComponent::kMinFaces, TRUE);
}
return true;
}
}
}
return false;
}
void DeleteThis() {}
};
static plGeoDiceComponentProc gGeoDiceProc;
//Max desc stuff necessary below.
CLASS_DESC(plGeoDiceComponent, gGeoDiceDesc, "Optimize Terrain", "OptimizeTerrain", COMP_TYPE_GRAPHICS, Class_ID(0x6f7a5713, 0x19595142))
ParamBlockDesc2 gGeoDiceBk
(
plComponent::kBlkComp, _T("GeoDice"), 0, &gGeoDiceDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_GEO_DICE, IDS_COMP_GEO_DICE, 0, 0, &gGeoDiceProc,
plGeoDiceComponent::kActive, _T("Active"), TYPE_BOOL, 0, 0,
p_default, TRUE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_GEO_DICE_ACTIVE,
end,
plGeoDiceComponent::kMaxFaces, _T("MaxFaces"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_COMP_GEO_DICE_MAXFACES, IDC_COMP_GEO_DICE_MAXFACES_SPIN, 1.f,
p_default, 1000,
p_range, 10, 10000,
end,
plGeoDiceComponent::kMaxSize, _T("MaxSize"), TYPE_FLOAT, 0, 0,
p_default, 100.0f,
p_range, 0.0, 10000.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT,
IDC_COMP_GEO_DICE_MAXSIZE, IDC_COMP_GEO_DICE_MAXSIZE_SPIN, 0.1f,
end,
plGeoDiceComponent::kMinFaces, _T("MinFaces"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_COMP_GEO_DICE_MINFACES, IDC_COMP_GEO_DICE_MINFACES_SPIN, 1.f,
p_default, 300,
p_range, 0, 5000,
end,
plGeoDiceComponent::kOverride, _T("Override"), TYPE_BOOL, 0, 0,
p_default, FALSE,
p_ui, TYPE_SINGLECHEKBOX, IDC_COMP_GEO_DICE_OVERRIDE,
end,
end
);
plGeoDiceComponent::plGeoDiceComponent()
{
fClassDesc = &gGeoDiceDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plGeoDiceComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
if( fCompPB->GetInt(kActive) )
{
pNode->SetGeoDice(true, fCompPB->GetInt(kMaxFaces), fCompPB->GetFloat(kMaxSize), fCompPB->GetInt(kMinFaces));
}
return true;
}
///
///
/// reference point component
/// put this on a dummy for a handy reference point you can use in python
///
///
class plReferencePointComponent : public plComponent
{
public:
plReferencePointComponent();
hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; }
// 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 *pNode, plErrorMsg *pErrMsg);
};
CLASS_DESC(plReferencePointComponent, gReferencePointDesc, "Reference Point", "RefPoint", COMP_TYPE_MISC, Class_ID(0x3c9c6f71, 0x5774fc5))
//Max paramblock2 stuff below.
ParamBlockDesc2 gReferencePointBk
(
1, _T("reference"), 0, &gReferencePointDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp,
end
);
plReferencePointComponent::plReferencePointComponent()
{
fClassDesc = &gReferencePointDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
hsBool plReferencePointComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
// all we need is a coordinate interface...
pNode->SetForceLocal(true);
return true;
}
///////////////////////////////////////////////////////////////////////////////
//
//
#include "../pnNetCommon/plSDLTypes.h"
#include "../MaxConvert/hsMaterialConverter.h"
#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayerInterface.h"
#include "plCreatableIndex.h"
class plNetSyncComponent : public plComponent
{
protected:
void ISetNetSync(plSynchedObject* so);
void ISetSDLType(plSynchedObject* so, int radioVal, const char* sdlName);
void ISetMtl(hsGMaterial* mtl);
public:
plNetSyncComponent();
// 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* errMsg);
virtual hsBool Convert(plMaxNode* node, plErrorMsg* errMsg) { return true; }
virtual hsBool DeInit(plMaxNode* node, plErrorMsg* errMsg);
};
CLASS_DESC(plNetSyncComponent, gNetSyncDesc, "Net Sync", "NetSync", COMP_TYPE_MISC, Class_ID(0x4d1b2d6f, 0x28fe08db))
enum
{
kNetSyncLocalOnly,
kNetSyncOverride,
kNetSyncPhys,
kNetSyncAnim,
kNetSyncSnd,
kNetSyncMat,
kNetSyncResp,
kNetSyncXReg,
};
enum
{
kNetSyncRadioAllow,
kNetSyncRadioNoSave,
kNetSyncRadioDeny,
};
class plNetSyncComponentProc : public ParamMap2UserDlgProc
{
protected:
void IEnableSDL(IParamMap2* map, bool enable)
{
map->Enable(kNetSyncPhys, enable);
map->Enable(kNetSyncAnim, enable);
map->Enable(kNetSyncSnd, enable);
map->Enable(kNetSyncMat, enable);
map->Enable(kNetSyncResp, enable);
map->Enable(kNetSyncXReg, enable);
}
void IEnableCtrls(IParamMap2* map)
{
IParamBlock2* pb = map->GetParamBlock();
if (pb->GetInt(kNetSyncLocalOnly))
{
map->Enable(kNetSyncOverride, FALSE);
IEnableSDL(map, false);
}
else if (pb->GetInt(kNetSyncOverride))
{
map->Enable(kNetSyncLocalOnly, FALSE);
IEnableSDL(map, true);
}
else
{
map->Enable(kNetSyncOverride, TRUE);
map->Enable(kNetSyncLocalOnly, TRUE);
IEnableSDL(map, false);
}
}
public:
BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
IEnableCtrls(map);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_LOCAL_ONLY_CHECK ||
LOWORD(wParam) == IDC_OVERRIDE_CHECK)
{
IEnableCtrls(map);
return TRUE;
}
break;
}
return FALSE;
}
void DeleteThis() {}
};
static plNetSyncComponentProc gNetSyncProc;
//Max paramblock2 stuff below.
ParamBlockDesc2 gHighSDLBk
(
plComponent::kBlkComp, _T("NetSync"), 0, &gNetSyncDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_NETSYNC, IDS_COMP_NETSYNC, 0, 0, &gNetSyncProc,
kNetSyncLocalOnly, _T("LocalOnly"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_LOCAL_ONLY_CHECK,
end,
kNetSyncOverride, _T("Override"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_OVERRIDE_CHECK,
end,
kNetSyncPhys, _T("PhysSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_PHYS_ALLOW_RADIO, IDC_PHYS_NOSAVE_RADIO, IDC_PHYS_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
kNetSyncAnim, _T("AnimSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_ANIM_ALLOW_RADIO, IDC_ANIM_NOSAVE_RADIO, IDC_ANIM_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
kNetSyncSnd, _T("SndSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_SND_ALLOW_RADIO, IDC_SND_NOSAVE_RADIO, IDC_SND_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
kNetSyncMat, _T("MatSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_MAT_ALLOW_RADIO, IDC_MAT_NOSAVE_RADIO, IDC_MAT_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
kNetSyncResp, _T("RespSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_RESP_ALLOW_RADIO, IDC_RESP_NOSAVE_RADIO, IDC_RESP_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
kNetSyncXReg, _T("XRegSDL"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_XREG_ALLOW_RADIO, IDC_XREG_NOSAVE_RADIO, IDC_XREG_DENY_RADIO,
p_vals, kNetSyncRadioAllow, kNetSyncRadioNoSave, kNetSyncRadioDeny,
p_default, kNetSyncRadioAllow,
end,
end
);
plNetSyncComponent::plNetSyncComponent()
{
fClassDesc = &gNetSyncDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plNetSyncComponent::SetupProperties(plMaxNode* node, plErrorMsg* errMsg)
{
// make all sdl types on this object Volatile
bool override = (fCompPB->GetInt(kNetSyncOverride) != 0);
node->SetOverrideHighLevelSDL(override);
return true;
}
void plNetSyncComponent::ISetSDLType(plSynchedObject* so, int radioVal, const char* sdlName)
{
switch (radioVal)
{
case kNetSyncRadioNoSave:
so->AddToSDLVolatileList(sdlName); // make volatile a type of persistence
break;
case kNetSyncRadioDeny:
so->AddToSDLExcludeList(sdlName); // disable a type of persistence
break;
}
}
void plNetSyncComponent::ISetNetSync(plSynchedObject* so)
{
// For local only, disable everything and exit
bool localOnly = (fCompPB->GetInt(kNetSyncLocalOnly) != 0);
if (localOnly)
{
so->SetLocalOnly(true);
return;
}
int physVal = fCompPB->GetInt(kNetSyncPhys);
int animVal = fCompPB->GetInt(kNetSyncAnim);
int sndVal = fCompPB->GetInt(kNetSyncSnd);
int matVal = fCompPB->GetInt(kNetSyncMat);
int respVal = fCompPB->GetInt(kNetSyncResp);
int xregVal = fCompPB->GetInt(kNetSyncXReg);
// If all are not saved, use that optimization
if (
physVal == kNetSyncRadioNoSave &&
animVal == kNetSyncRadioNoSave &&
sndVal == kNetSyncRadioNoSave &&
matVal == kNetSyncRadioNoSave &&
respVal == kNetSyncRadioNoSave &&
xregVal == kNetSyncRadioNoSave
)
{
so->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
}
// If all are volatile, use that optimization
else if (
physVal == kNetSyncRadioDeny &&
animVal == kNetSyncRadioDeny &&
sndVal == kNetSyncRadioDeny &&
matVal == kNetSyncRadioDeny &&
respVal == kNetSyncRadioDeny &&
xregVal == kNetSyncRadioDeny
)
{
so->SetSynchFlagsBit(plSynchedObject::kExcludeAllPersistentState);
}
// If it's a mix, we need to set them individually
else
{
ISetSDLType(so, physVal, kSDLPhysical);
ISetSDLType(so, animVal, kSDLAGMaster);
ISetSDLType(so, sndVal, kSDLSound);
ISetSDLType(so, matVal, kSDLLayer);
ISetSDLType(so, respVal, kSDLResponder);
ISetSDLType(so, xregVal, kSDLXRegion);
}
}
void plNetSyncComponent::ISetMtl(hsGMaterial* mtl)
{
for (int i = 0; i < mtl->GetNumLayers(); i++)
{
plLayerInterface* layer = mtl->GetLayer(i);
while (layer)
{
if (layer->ClassIndex() == CLASS_INDEX_SCOPED(plLayerAnimation) ||
layer->ClassIndex() == CLASS_INDEX_SCOPED(plLayerSDLAnimation))
{
ISetNetSync(layer);
}
layer = layer->GetAttached();
}
}
}
// We're cheating and using DeInit as an extra pass, since everything should be done at that point
hsBool plNetSyncComponent::DeInit(plMaxNode* node, plErrorMsg* errMsg)
{
plSceneObject* so = node->GetSceneObject();
if (!so)
return false;
// Set sync options on the sceneobject
ISetNetSync(so);
// Then on the textures...
Mtl* maxMaterial = hsMaterialConverter::Instance().GetBaseMtl(node);
if (maxMaterial)
{
hsTArray<hsGMaterial*> matArray;
// Get the textures from the material converter
if (hsMaterialConverter::Instance().IsMultiMat(maxMaterial))
{
int numMaterials = maxMaterial->NumSubMtls();
for (int i = 0; i < numMaterials; i++)
hsMaterialConverter::Instance().GetMaterialArray(maxMaterial->GetSubMtl(i), node, matArray, i);
}
else
hsMaterialConverter::Instance().GetMaterialArray(maxMaterial, node, matArray);
// Set sync on the textures we found
for (int i = 0; i < matArray.GetCount(); i++)
{
hsGMaterial* mtl = matArray[i];
if (mtl)
ISetMtl(mtl);
}
}
return true;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// Image Lib Component
//
//
class pfImageLibProc : public ParamMap2UserDlgProc
{
protected:
void IRefreshImageList( HWND hDlg, pfImageLibComponent *comp )
{
HWND ctrl = GetDlgItem( hDlg, IDC_IMAGE_LIST );
HDC dc = GetDC( ctrl );
LONG maxWidth = 0;
SendMessage( ctrl, LB_RESETCONTENT, 0, 0 );
for( int i = 0; i < comp->GetNumBitmaps(); i++ )
{
plLayerTex *layer = comp->GetBitmap( i );
if( layer != nil )
{
const char *str = layer->GetPBBitmap()->bi.Filename();
int idx = SendMessage( ctrl, LB_ADDSTRING, 0, (LPARAM)str );
SendMessage( ctrl, LB_SETITEMDATA, (WPARAM)idx, (LPARAM)i );
SIZE strSize;
GetTextExtentPoint32( dc, str, strlen(str), &strSize );
if( strSize.cx > maxWidth )
maxWidth = strSize.cx;
}
}
SendMessage( ctrl, LB_SETHORIZONTALEXTENT, (WPARAM)maxWidth, NULL );
ReleaseDC( ctrl, dc );
EnableWindow( GetDlgItem( hDlg, IDC_IMAGE_EDIT ), false );
EnableWindow( GetDlgItem( hDlg, IDC_IMAGE_REMOVE ), false );
CheckDlgButton(hDlg, IDC_IL_COMPRESS, BST_UNCHECKED);
CheckDlgButton(hDlg, IDC_IL_FORCEPOW2, BST_UNCHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_IL_COMPRESS), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_IL_FORCEPOW2), FALSE);
}
public:
void DeleteThis() {}
// virtual void Update( TimeValue t, Interval &valid, IParamMap2 *map );
BOOL DlgProc( TimeValue t, IParamMap2 *pmap, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
IParamBlock2 *pb = pmap->GetParamBlock();
pfImageLibComponent *comp = (pfImageLibComponent *)pb->GetOwner();
switch( msg )
{
case WM_INITDIALOG:
// Fill our list with bitmap filenames
comp->Validate();
IRefreshImageList( hWnd, comp );
return true;
case WM_DESTROY:
break;
case WM_COMMAND:
if( LOWORD( wParam ) == IDC_IMAGE_ADD )
{
plLayerTex *newLayer = TRACKED_NEW plLayerTex;
if( newLayer->HandleBitmapSelection() )
{
comp->AppendBitmap( newLayer );
IRefreshImageList( hWnd, comp );
}
}
else if( LOWORD( wParam ) == IDC_IMAGE_EDIT )
{
int idx = SendDlgItemMessage( hWnd, IDC_IMAGE_LIST, LB_GETCURSEL, 0, 0 );
if( idx != LB_ERR )
{
idx = SendDlgItemMessage( hWnd, IDC_IMAGE_LIST, LB_GETITEMDATA, (WPARAM)idx, 0 );
plLayerTex *layer = comp->GetBitmap( idx );
if( layer != nil && layer->HandleBitmapSelection() )
{
IRefreshImageList( hWnd, comp );
}
}
}
else if( LOWORD( wParam ) == IDC_IMAGE_REMOVE )
{
int idx = SendDlgItemMessage( hWnd, IDC_IMAGE_LIST, LB_GETCURSEL, 0, 0 );
if( idx != LB_ERR )
{
idx = SendDlgItemMessage( hWnd, IDC_IMAGE_LIST, LB_GETITEMDATA, (WPARAM)idx, 0 );
comp->RemoveBitmap( idx );
IRefreshImageList( hWnd, comp );
}
return false;
}
else if( LOWORD( wParam ) == IDC_IMAGE_LIST && HIWORD( wParam ) == LBN_SELCHANGE )
{
int idx = SendDlgItemMessage( hWnd, IDC_IMAGE_LIST, LB_GETCURSEL, 0, 0 );
EnableWindow( GetDlgItem( hWnd, IDC_IMAGE_EDIT ), idx != LB_ERR );
EnableWindow( GetDlgItem( hWnd, IDC_IMAGE_REMOVE ), idx != LB_ERR );
EnableWindow(GetDlgItem(hWnd, IDC_IL_COMPRESS), TRUE);
CheckDlgButton(hWnd, IDC_IL_COMPRESS, comp->GetCompress(idx) ? BST_CHECKED : BST_UNCHECKED);
}
else if (LOWORD(wParam) == IDC_IL_COMPRESS && HIWORD(wParam) == BN_CLICKED)
{
bool checked = (IsDlgButtonChecked(hWnd, IDC_IL_COMPRESS) == BST_CHECKED);
int sel = ListBox_GetCurSel(GetDlgItem(hWnd, IDC_IMAGE_LIST));
comp->SetCompress(sel, checked);
}
break;
}
return false;
}
};
static pfImageLibProc gImageLibProc;
//Max desc stuff necessary below.
CLASS_DESC(pfImageLibComponent, gImageLibDesc, "Image Library", "ImageLib", COMP_TYPE_MISC, IMAGE_LIB_CID )
ParamBlockDesc2 gImageLibBlock
( // KLUDGE: not the defined block ID, but kept for backwards compat.
1, _T("Image Lib"), 0, &gImageLibDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,
IDD_COMP_IMAGELIB, IDS_COMP_IMAGELIB, 0, 0, &gImageLibProc,
// params
pfImageLibComponent::kRefImageList, _T("imageList"), TYPE_TEXMAP_TAB, 0, 0, 0,
end,
pfImageLibComponent::kCompressImage, _T("compress"), TYPE_BOOL_TAB, 0, 0, 0,
p_default, 1,
end,
end
);
pfImageLibComponent::pfImageLibComponent()
{
fClassDesc = &gImageLibDesc;
fClassDesc->MakeAutoParamBlocks(this);
}
void pfImageLibComponent::Validate()
{
if (fCompPB->Count(kCompressImage) != fCompPB->Count(kRefImageList))
fCompPB->SetCount(kCompressImage, fCompPB->Count(kRefImageList));
}
int pfImageLibComponent::GetNumBitmaps( void ) const
{
return fCompPB->Count( (ParamID)kRefImageList );
}
plLayerTex *pfImageLibComponent::GetBitmap( int idx )
{
// If we don't have one, create one
plLayerTex *layer = (plLayerTex *)fCompPB->GetTexmap( (ParamID)kRefImageList, 0, idx );
if( layer == nil || layer->ClassID() != LAYER_TEX_CLASS_ID )
{
layer = TRACKED_NEW plLayerTex;
fCompPB->SetValue( (ParamID)kRefImageList, 0, (Texmap *)layer, idx );
}
return layer;
}
int pfImageLibComponent::AppendBitmap( plLayerTex *tex )
{
int idx = GetNumBitmaps();
fCompPB->Resize( (ParamID)kRefImageList, idx + 1 );
fCompPB->SetValue( (ParamID)kRefImageList, 0, (Texmap *)tex, idx );
fCompPB->Resize(kCompressImage, idx + 1);
return idx;
}
void pfImageLibComponent::RemoveBitmap( int idx )
{
fCompPB->Delete( (ParamID)kRefImageList, idx, 1 );
fCompPB->Delete(kCompressImage, idx, 1);
}
bool pfImageLibComponent::GetCompress(int idx)
{
return (fCompPB->GetInt(kCompressImage, 0, idx) != 0);
}
void pfImageLibComponent::SetCompress(int idx, bool compress)
{
fCompPB->SetValue(kCompressImage, 0, compress, idx);
}
hsBool pfImageLibComponent::SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg)
{
Validate();
return true;
}
hsBool pfImageLibComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
plImageLibMod *lib = TRACKED_NEW plImageLibMod;
node->AddModifier( lib, IGetUniqueName(node) );
int i;
for( i = 0; i < GetNumBitmaps(); i++ )
{
plLayerTex *layer = GetBitmap( i );
if( layer != nil )
{
PBBitmap *texture = layer->GetPBBitmap();
if( texture != nil )
{
UInt32 flags = plBitmap::kAlphaChannelFlag;
plBitmap *bMap;
if (fCompPB->GetInt(kCompressImage, 0, i) == 0)
{
flags |= plBitmap::kForceNonCompressed;
bMap = plLayerConverter::Instance().CreateSimpleTexture( texture->bi.Name(), lib->GetKey()->GetUoid().GetLocation(), 0, flags );
}
else // compress using JPEG compression scheme
bMap = plLayerConverter::Instance().CreateSimpleTexture( texture->bi.Name(), lib->GetKey()->GetUoid().GetLocation(), 0, flags, true );
if( bMap != nil )
{
hsgResMgr::ResMgr()->AddViaNotify( bMap->GetKey(), TRACKED_NEW plGenRefMsg( lib->GetKey(),
plRefMsg::kOnCreate, lib->GetNumImages(), plImageLibMod::kRefImage ), plRefFlags::kActiveRef );
}
}
}
}
return true;
}