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.
71 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: e825206eb6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e825206eb6'
${ noResults }
CWE-ou-minkata/Sources/Tools/MaxConvert/plConvert.cpp

498 lines
15 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==*/
//
// 3DSMax HeadSpin exporter
//
#include "hsTypes.h"
#include "Max.h"
#include "istdplug.h"
#include "Notify.h"
#include <commdlg.h>
#include "bmmlib.h"
#include "INode.h"
#include "plConvert.h"
#include "hsResMgr.h"
#include "hsTemplates.h"
#include "hsConverterUtils.h"
#include "hsControlConverter.h"
#include "plMeshConverter.h"
#include "hsMaterialConverter.h"
#include "plLayerConverter.h"
#include "UserPropMgr.h"
#include "hsStringTokenizer.h"
#include "../MaxExport/plErrorMsg.h"
#include "hsVertexShader.h"
#include "plLightMapGen.h"
#include "plBitmapCreator.h"
#include "plgDispatch.h"
#include "../pnMessage/plTimeMsg.h"
#include "../MaxComponent/plComponent.h"
#include "../MaxMain/plMaxNode.h"
#include "../plMessage/plNodeCleanupMsg.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../MaxComponent/plClusterComponent.h"
#include "../plPhysX/plSimulationMgr.h"
#include "../MaxMain/plPhysXCooking.h"
#include "../MaxExport/plExportProgressBar.h"
#include "hsUtils.h"
#include "../MaxMain/plGetLocationDlg.h"
#ifdef HS_DEBUGGING
#define HS_NO_TRY
#endif
plConvert::plConvert() : fWarned(0)
{
}
plConvert& plConvert::Instance()
{
static plConvert theInstance;
return theInstance;
}
hsBool plConvert::IOK()
{
return (!fQuit && !fpErrorMsg->IsBogus() ) ? true: false;
}
hsBool plConvert::Convert()
{
#ifndef HS_NO_TRY
try
#endif
{
fSettings->fReconvert = false;
fWarned = 0;
fInterface->SetIncludeXRefsInHierarchy(TRUE);
plMaxNode *pNode = (plMaxNode *)fInterface->GetRootNode();
AddMessageToQueue(new plTransformMsg(nil, nil, nil, nil));
AddMessageToQueue(new plDelayedTransformMsg(nil, nil, nil, nil));
IFindDuplicateNames();
plExportProgressBar bar;
hsBool retVal = true; // sometime, we might look at this
if( !IAutoClusterRecur(pNode) )
{
fQuit = true;
}
if(IOK())
{
bar.Start("Clear Old Data");
retVal = pNode->DoAllRecur( plMaxNode::ClearData, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Convert Validate");
retVal = pNode->DoRecur( plMaxNode::ConvertValidate, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Components Initialize");
retVal = pNode->DoRecur( plMaxNode::SetupPropertiesPass, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Prepare for skinning");
retVal = pNode->DoRecur( plMaxNode::PrepareSkin, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Make Scene Object");
retVal = pNode->DoRecur( plMaxNode::MakeSceneObject, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Make Physical");
plPhysXCooking::Init();
retVal = pNode->DoRecur( plMaxNode::MakePhysical, fpErrorMsg, fSettings, &bar );
plPhysXCooking::Shutdown();
}
if(IOK())
{
bar.Start("Component Preconvert");
retVal = pNode->DoRecur( plMaxNode::FirstComponentPass, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Make Controller");
retVal = pNode->DoRecur( plMaxNode::MakeController, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // must be before mesh
bar.Start("Make Coord Interface");
retVal = pNode->DoRecur( plMaxNode::MakeCoordinateInterface, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // must be after coord interface but before pool data is created.
bar.Start("Make Connections");
retVal = pNode->DoRecur( plMaxNode::MakeParentOrRoomConnection, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // must be before simulation
bar.Start("Make Mesh");
retVal = pNode->DoRecur( plMaxNode::MakeMesh, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // doesn't matter when
bar.Start("Make Light");
retVal = pNode->DoRecur( plMaxNode::MakeLight, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // doesn't matter when
bar.Start("Make Occluder");
retVal = pNode->DoRecur( plMaxNode::MakeOccluder, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{ // must be after mesh
bar.Start("Make Modifiers");
retVal = pNode->DoRecur( plMaxNode::MakeModifiers, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
bar.Start("Convert Components");
retVal = pNode->DoRecur( plMaxNode::ConvertComponents, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
// do this after convert
bar.Start("Set Up Interface References");
retVal = pNode->DoRecur( plMaxNode::MakeIfaceReferences, fpErrorMsg, fSettings, &bar );
}
if(IOK() && fSettings->fDoPreshade)
{
// These need to be opened after the components have had a chance to flag the MaxNodes
plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
hsVertexShader::Instance().Open();
bar.Start("Preshade Geometry");
retVal = pNode->DoRecur( plMaxNode::ShadeMesh, fpErrorMsg, fSettings, &bar );
plLightMapGen::Instance().Close();
hsVertexShader::Instance().Close();
}
if(IOK())
{
// Do this next-to-last--allows all the components to free up any temp data they kept around
bar.Start("Component DeInit");
retVal = pNode->DoRecur( plMaxNode::DeInitComponents, fpErrorMsg, fSettings, &bar );
}
if(IOK())
{
// Do this very last--it de-inits and frees all the maxNodeDatas lying around
bar.Start("Clear MaxNodeDatas");
retVal = pNode->DoAllRecur( plMaxNode::ClearMaxNodeData, fpErrorMsg, fSettings, &bar );
}
// fpErrorMsg->Set();
DeInit();
fInterface->SetIncludeXRefsInHierarchy(FALSE);
return IOK();
}
#ifndef HS_NO_TRY
catch(plErrorMsg& err)
{
DeInit();
fInterface->SetIncludeXRefsInHierarchy(FALSE);
err.Show();
return false;
}
catch(...)
{
DeInit();
fInterface->SetIncludeXRefsInHierarchy(FALSE);
fpErrorMsg->Set(true, "plConvert", "Unknown error during convert\n");
fpErrorMsg->Show();
return false;
}
#endif
}
//#include "../MaxMain/plMaxNodeData.h"
//#include <set>
hsBool ConvertList(hsTArray<plMaxNode*>& nodes, PMaxNodeFunc p, plErrorMsg *errMsg, plConvertSettings *settings)
{
for (int i = 0; i < nodes.Count(); i++)
{
(nodes[i]->*p)(errMsg, settings);
if (errMsg && errMsg->IsBogus())
return false;
}
return true;
}
hsBool plConvert::Convert(hsTArray<plMaxNode*>& nodes)
{
#ifndef HS_NO_TRY
try
#endif
{
fSettings->fReconvert = true;
hsBool retVal = true;
if (IOK())
retVal = ConvertList(nodes, plMaxNode::ClearData, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::ConvertValidate, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::SetupPropertiesPass, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::PrepareSkin, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::MakeSceneObject, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::FirstComponentPass, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::MakeController, fpErrorMsg,fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::MakeCoordinateInterface, fpErrorMsg, fSettings);// must be before mesh
if(IOK())
retVal = ConvertList(nodes, plMaxNode::MakeParentOrRoomConnection, fpErrorMsg, fSettings); // after coord, before mesh (or any other pool data).
// These shouldn't be opened until the components have had a chance to flag the MaxNodes
plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
hsVertexShader::Instance().Open();
if(IOK())
retVal = ConvertList(nodes, plMaxNode::MakeMesh, fpErrorMsg, fSettings); // must be before simulation
if(IOK()) // doesn't matter when
retVal = ConvertList(nodes, plMaxNode::MakeLight, fpErrorMsg, fSettings);
if(IOK()) // doesn't matter when
retVal = ConvertList(nodes, plMaxNode::MakeOccluder, fpErrorMsg, fSettings);
if(IOK()) // must be after mesh
retVal = ConvertList(nodes, plMaxNode::MakeModifiers, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::ConvertComponents, fpErrorMsg, fSettings);
if(IOK())
retVal = ConvertList(nodes, plMaxNode::ShadeMesh, fpErrorMsg, fSettings);
// These may be used by components, so don't close them till the end.
plLightMapGen::Instance().Close();
hsVertexShader::Instance().Close();
plgDispatch::MsgSend(new plTransformMsg(nil, nil, nil, nil));
plgDispatch::MsgSend(new plDelayedTransformMsg(nil, nil, nil, nil));
DeInit();
return IOK();
}
#ifndef HS_NO_TRY
catch(plErrorMsg& err)
{
err.Show();
return false;
}
catch(...)
{
hsMessageBox("Unknown error during convert", "plConvert", hsMessageBoxNormal);
return false;
}
#endif
}
hsBool plConvert::Init(Interface *ip, plErrorMsg* msg, plConvertSettings *settings)
{
fInterface = ip;
fpErrorMsg = msg;
fSettings = settings;
// Move us to time 0, so that things like initial transforms are always consistent with the 0th frame.
// This saves our asses from things like the patch-generation process later
ip->SetTime( 0, false );
hsConverterUtils::Instance().Init(true, fpErrorMsg);
plBitmapCreator::Instance().Init(true, fpErrorMsg);
hsMaterialConverter::Instance().Init(true, fpErrorMsg);
hsControlConverter::Instance().Init(fpErrorMsg);
plMeshConverter::Instance().Init(true, fpErrorMsg);
plLayerConverter::Instance().Init(true, fpErrorMsg);
plGetLocationDlg::Instance().ResetDefaultLocation();
fQuit = false;
return true;
}
void plConvert::DeInit()
{
// Undo any autogenerated clusters.
IAutoUnClusterRecur(fInterface->GetRootNode());
// clear out the message queue
for (int i = 0; i < fMsgQueue.Count(); i++)
plgDispatch::MsgSend(fMsgQueue[i]);
fMsgQueue.Reset();
hsControlConverter::Instance().DeInit();
plMeshConverter::Instance().DeInit();
plLayerConverter::Instance().DeInit();
// Moving this to the end of writing the files out. Yes, this means that any unused mipmaps still get
// written to disk, including ones loaded on preload, but it's the only way to get shared texture pages
// to work without loading in the entire age worth of reffing objects. - 5.30.2002 mcn
// plBitmapCreator::Instance().DeInit();
plNodeCleanupMsg *clean = TRACKED_NEW plNodeCleanupMsg();
plgDispatch::MsgSend( clean );
}
void plConvert::AddMessageToQueue(plMessage* msg)
{
fMsgQueue.Append(msg);
}
void plConvert::SendEnvironmentMessage(plMaxNode* pNode, plMaxNode* efxRegion, plMessage* msg, hsBool ignorePhysicals )
{
for (int i = 0; i < pNode->NumberOfChildren(); i++)
SendEnvironmentMessage((plMaxNode *)pNode->GetChildNode(i), efxRegion, msg, ignorePhysicals );
// don't call ourself...
if (pNode == efxRegion)
return;
// send the scene object this message:
if (efxRegion->Contains( ((INode*)pNode)->GetNodeTM(hsConverterUtils::Instance().GetTime(pNode->GetInterface())).GetRow(3)) &&
pNode->GetSceneObject() && ( !ignorePhysicals || !pNode->IsPhysical() ) )
msg->AddReceiver( pNode->GetSceneObject()->GetKey() );
}
plMaxNode* plConvert::GetRootNode()
{
return (plMaxNode *)fInterface->GetRootNode();
}
BOOL plConvert::IAutoClusterRecur(INode* node)
{
plMaxNode* maxNode = (plMaxNode*)node;
plComponentBase* comp = maxNode->ConvertToComponent();
if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
{
plClusterComponent* clust = (plClusterComponent*)comp;
// Cluster decides if it needs autogen
if( clust->AutoGen(fpErrorMsg) )
return false;
}
int i;
for( i = 0; i < node->NumberOfChildren(); i++ )
{
if( !IAutoClusterRecur(node->GetChildNode(i)) )
return false;
}
return true;
}
BOOL plConvert::IAutoUnClusterRecur(INode* node)
{
plMaxNode* maxNode = (plMaxNode*)node;
plComponentBase* comp = maxNode->ConvertToComponent();
if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
{
plClusterComponent* clust = (plClusterComponent*)comp;
// Cluster remembers whether it was autogen'd.
clust->AutoClear(fpErrorMsg);
}
int i;
for( i = 0; i < node->NumberOfChildren(); i++ )
{
IAutoUnClusterRecur(node->GetChildNode(i));
}
return true;
}
bool plConvert::IFindDuplicateNames()
{
INode *node = fInterface->GetRootNode();
const char *name = ISearchNames(node, node);
if (!name)
return false;
fpErrorMsg->Set(true,
"Error in Conversion of Scene Objects",
"Two objects in the scene share the name '%s'.\nUnique names are necessary during the export process.\n",
name
);
fpErrorMsg->Show();
return true;
}
// Recursivly search nodes for duplicate names, and return when one is found
const char *plConvert::ISearchNames(INode *node, INode *root)
{
int count = ICountNameOccurances(root, node->GetName());
if (count > 1)
return node->GetName();
for (int i = 0; i < node->NumberOfChildren(); i++)
{
const char *name = ISearchNames(node->GetChildNode(i), root);
if (name)
return name;
}
return nil;
}
// Recursivly search nodes for this name, and return the number of times found
int plConvert::ICountNameOccurances(INode *node, const char *name)
{
int count = 0;
if (!stricmp(name, node->GetName()))
count++;
for (int i = 0; i < node->NumberOfChildren(); i++)
count += ICountNameOccurances(node->GetChildNode(i), name);
return count;
}