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.

4121 lines
118 KiB

/*==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/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
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 "iparamm2.h"
#include "iparamb2.h"
#include "ISkin.h"
#include "MNMath.h"
#include "plMaxNode.h"
//#include "../MaxComponent/resource.h"
#include "GlobalUtility.h"
#include "plgDispatch.h"
#include "plPluginResManager.h"
#include "plMaxNodeData.h"
#include "hsUtils.h"
#include "../MaxConvert/plConvert.h"
#include "hsTemplates.h"
#include "hsStringTokenizer.h"
#include "../MaxConvert/hsConverterUtils.h"
#include "../MaxConvert/hsControlConverter.h"
#include "../MaxConvert/plMeshConverter.h"
#include "../MaxConvert/hsMaterialConverter.h"
#include "../MaxConvert/plLayerConverter.h"
#include "../MaxConvert/UserPropMgr.h"
#include "../MaxExport/plErrorMsg.h"
#include "../MaxConvert/hsVertexShader.h"
#include "../MaxConvert/plLightMapGen.h"
#include "plMaxMeshExtractor.h"
#include "../MaxPlasmaMtls/Layers/plLayerTex.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../plScene/plSceneNode.h"
#include "../plPhysX/plPXPhysical.h"
#include "../plDrawable/plInstanceDrawInterface.h"
#include "../plDrawable/plSharedMesh.h"
#include "../pnSceneObject/plSimulationInterface.h"
#include "../pnSceneObject/plAudioInterface.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pfAnimation/plFilterCoordInterface.h"
#include "../plParticleSystem/plBoundInterface.h"
#include "../plPhysical/plPickingDetector.h"
#include "../plModifier/plLogicModifier.h"
#include "../plModifier/plResponderModifier.h"
#include "../plModifier/plInterfaceInfoModifier.h"
#include "../pfAnimation/plLightModifier.h"
#include "../pfCharacter/plPlayerModifier.h"
#include "../plAvatar/plAGModifier.h"
#include "../plAvatar/plAGAnim.h"
#include "../plAvatar/plPointChannel.h"
#include "../plAvatar/plScalarChannel.h"
#include "../plAvatar/plAGMasterMod.h"
#include "../plMessage/plReplaceGeometryMsg.h"
#include "../plGImage/plMipmap.h"
#include "../plModifier/plSpawnModifier.h"
#include "../plInterp/plController.h"
#include "../plInterp/hsInterp.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pfAnimation/plViewFaceModifier.h" // mf horse temp hack testing to be thrown away
#include "../plScene/plOccluder.h"
#include "hsFastMath.h"
#include "../plDrawable/plDrawableSpans.h"
#include "../plDrawable/plGeometrySpan.h"
#include "../plPipeline/plFogEnvironment.h"
#include "../plGLight/plLightInfo.h"
#include "../plGLight/plLightKonstants.h"
#include "../plSurface/plLayerInterface.h"
#include "../plSurface/plLayer.h"
#include "../plSurface/hsGMaterial.h"
#include "../pnMessage/plObjRefMsg.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "../pnMessage/plIntRefMsg.h"
#include "../MaxExport/plExportProgressBar.h"
#include "../MaxPlasmaMtls/Materials/plDecalMtl.h"
#include "../MaxComponent/plComponentTools.h"
#include "../MaxComponent/plComponent.h"
#include "../MaxComponent/plComponentExt.h"
#include "../MaxComponent/plFlexibilityComponent.h"
#include "../MaxComponent/plLightMapComponent.h"
#include "../MaxComponent/plXImposter.h"
#include "../MaxComponent/plMiscComponents.h"
#include "../plParticleSystem/plParticleSystem.h"
#include "../plParticleSystem/plParticleEmitter.h"
#include "../plParticleSystem/plParticleEffect.h"
#include "../plParticleSystem/plParticleGenerator.h"
#include "../plParticleSystem/plConvexVolume.h"
#include "../MaxPlasmaLights/plRealTimeLightBase.h"
#include "../MaxPlasmaLights/plRTProjDirLight.h"
extern UserPropMgr gUserPropMgr;
hsBool ThreePlaneIntersect(const hsVector3& norm0, const hsPoint3& point0,
const hsVector3& norm1, const hsPoint3& point1,
const hsVector3& norm2, const hsPoint3& point2, hsPoint3& loc);
// Begin external component toolbox ///////////////////////////////////////////////////////////////
static plKey ExternAddModifier(plMaxNodeBase *node, plModifier *mod)
{
return nil;//((plMaxNode*)node)->AddModifier(mod);
}
static plKey ExternGetNewKey(const char *name, plModifier *mod, plLocation loc)
{
return nil;//hsgResMgr::ResMgr()->NewKey(name, mod, loc);
}
// In plResponderComponent (for no apparent reason).
int GetMatAnimModKey(Mtl* mtl, plMaxNodeBase* node, const char *segName, hsTArray<plKey>& keys);
// In plAudioComponents
int GetSoundNameAndIdx(plComponentBase *comp, plMaxNodeBase *node, const char*& name);
#include "../MaxComponent/plAnimComponent.h"
static const char *GetAnimCompAnimName(plComponentBase *comp)
{
if (comp->ClassID() == ANIM_COMP_CID || comp->ClassID() == ANIM_GROUP_COMP_CID)
return ((plAnimComponentBase*)comp)->GetAnimName();
return nil;
}
static plKey GetAnimCompModKey(plComponentBase *comp, plMaxNodeBase *node)
{
if (comp->ClassID() == ANIM_COMP_CID || comp->ClassID() == ANIM_GROUP_COMP_CID)
return ((plAnimComponentBase*)comp)->GetModKey((plMaxNode*)node);
return nil;
}
plComponentTools gComponentTools(ExternAddModifier,
ExternGetNewKey,
nil,
GetAnimCompModKey,
GetAnimCompAnimName,
GetMatAnimModKey,
GetSoundNameAndIdx);
// End external component toolbox //////////////////////////////////////////////////////////////////
void plMaxBoneMap::AddBone(plMaxNodeBase *bone)
{
char *dbgNodeName = bone->GetName();
if (fBones.find(bone) == fBones.end())
fBones[bone] = fNumBones++;
}
void plMaxBoneMap::FillBoneArray(plMaxNodeBase **boneArray)
{
BoneMap::const_iterator boneIt = fBones.begin();
for (; boneIt != fBones.end(); boneIt++)
boneArray[(*boneIt).second] = (*boneIt).first;
}
UInt8 plMaxBoneMap::GetIndex(plMaxNodeBase *bone)
{
hsAssert(fBones.find(bone) != fBones.end(), "Bone missing in remap!");
return fBones[bone];
}
UInt32 plMaxBoneMap::GetBaseMatrixIndex(plDrawable *draw)
{
if (fBaseMatrices.find(draw) == fBaseMatrices.end())
return (UInt32)-1;
return fBaseMatrices[draw];
}
void plMaxBoneMap::SetBaseMatrixIndex(plDrawable *draw, UInt32 idx)
{
fBaseMatrices[draw] = idx;
}
// Don't call this after you've started assigning indices to spans, or
// you'll be hosed (duh).
void plMaxBoneMap::SortBones()
{
plMaxNodeBase **tempBones = TRACKED_NEW plMaxNodeBase*[fNumBones];
FillBoneArray(tempBones);
// Look ma! An n^2 bubble sort!
// (It's a 1-time thing for an array of less than 100 items. Speed is not essential here)
int i,j;
for (i = 0; i < fNumBones; i++)
{
hsBool swap = false;
for (j = i + 1; j < fNumBones; j++)
{
if (strcmp(tempBones[i]->GetName(), tempBones[j]->GetName()) > 0)
{
plMaxNodeBase *temp = tempBones[i];
tempBones[i] = tempBones[j];
tempBones[j] = temp;
swap = true;
}
}
if (!swap)
break;
}
for (i = 0; i < fNumBones; i++)
fBones[tempBones[i]] = i;
delete [] tempBones;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
plKey plMaxNode::AddModifier(plModifier *pMod, const char* name)
{
plKey modKey = pMod->GetKey();
if (!modKey)
modKey = hsgResMgr::ResMgr()->NewKey(name, pMod, GetLocation());
hsgResMgr::ResMgr()->AddViaNotify(modKey, TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
return modKey;
}
hsBool plMaxNode::DoRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConvertSettings *settings,plExportProgressBar*bar)
{
#ifdef HS_DEBUGGING
const char *tmpName = GetName();
#endif
// If there is a progess bar, update it with the current node
// If the user cancels during the update, set bogus so we'll exit
if (bar && bar->Update(GetName()))
{
pErrMsg->Set(true);
return false;
}
// If we can't convert (and we aren't the root node) stop recursing.
if (!IsRootNode() && !CanConvert())
return false;
(this->*pDoFunction)(pErrMsg, settings);
for (int i = 0; (!pErrMsg || !pErrMsg->IsBogus()) && i < NumberOfChildren(); i++)
{
plMaxNode *pChild = (plMaxNode *)GetChildNode(i);
pChild->DoRecur(pDoFunction, pErrMsg, settings, bar);
}
return true;
}
// This is the same as DoRecur except that it ignores the canconvert field. We
// need this for things like clearing the old data, where we need to ignore the old value.
hsBool plMaxNode::DoAllRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConvertSettings *settings,plExportProgressBar*bar)
{
#ifdef HS_DEBUGGING
const char *tmpName = GetName();
#endif
// If there is a progess bar, update it with the current node
// If the user cancels during the update, set bogus so we'll exit
if (bar && bar->Update(GetName()))
{
pErrMsg->Set(true);
return false;
}
(this->*pDoFunction)(pErrMsg, settings);
for (int i = 0; (!pErrMsg || !pErrMsg->IsBogus()) && i < NumberOfChildren(); i++)
{
plMaxNode *pChild = (plMaxNode *)GetChildNode(i);
pChild->DoAllRecur(pDoFunction, pErrMsg, settings, bar);
}
return true;
}
hsBool plMaxNode::ConvertValidate(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
TimeValue t = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState( t ).obj;
const char* dbgName = GetName();
// Always want to recalculate if this object can convert at this point.
// In general there won't be any cached flag anyway, but in the SceneViewer
// there can be if we're reconverting.
hsBool canConvert = CanConvert(true);
plMaxNodeData thisNodeData; // Extra data stored for each node
if (IsTarget())
{
plMaxNode* targetNode = ((plMaxNode*)GetLookatNode());
if (targetNode)
{
Object* targObj = targetNode->EvalWorldState( 0 ).obj;
if (targObj && targObj->SuperClassID() == CAMERA_CLASS_ID)
canConvert = true;
else
canConvert = false;
}
else
canConvert = false;
}
if (canConvert && obj->SuperClassID() == LIGHT_CLASS_ID)
{
thisNodeData.SetDrawable(false);
thisNodeData.SetRunTimeLight(true);
thisNodeData.SetForceLocal(true);
}
if (UserPropExists("Occluder"))
{
// thisNodeData.SetDrawable(false);
}
if( UserPropExists("PSRunTimeLight") )
thisNodeData.SetRunTimeLight(true);
if (GetParticleRelated())
thisNodeData.SetForceLocal(true);
// if (UserPropExists("cloth"))
// {
// thisNodeData.SetForceLocal(true);
// }
// If we want a physicals only world, set everything to not drawable by default.
if (settings->fPhysicalsOnly)
thisNodeData.SetDrawable(false);
// Remember info in MaxNodeData block for later
thisNodeData.SetCanConvert(canConvert);
SetMaxNodeData(&thisNodeData);
#define MF_DISABLE_INSTANCING
#ifndef MF_DISABLE_INSTANCING
// Send this node off to the instance list, to see if we're instanced
if( CanMakeMesh( obj, pErrMsg, settings ) )
{
hsTArray<plMaxNode *> nodes;
UInt32 numInstances = IBuildInstanceList( GetObjectRef(), t, nodes );
if( numInstances > 1 )
{
/// INSTANCED. Make sure to force local on us
SetForceLocal( true );
SetInstanced( true );
}
}
#endif // MF_DISABLE_INSTANCING
// If this is for the SceneViewer, turn off the dirty flags so we won't try
// reconverting this node again.
if (settings->fSceneViewer)
SetDirty(kAllDirty, false);
return canConvert;
}
hsBool plMaxNode::ClearMaxNodeData(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// The right place to delete the boneMap is really in ~plMaxNodeData, but that class
// is only allowed to know about stuff in nucleusLib.
if (GetBoneMap() && GetBoneMap()->fOwner == this)
delete GetBoneMap();
if (GetSwappableGeom())
{
// Ref and unref it, so it goes away if no one kept it around (i.e. we just
// looked at the mesh during export for reference, but don't want to keep it.)
GetSwappableGeom()->GetKey()->RefObject();
GetSwappableGeom()->GetKey()->UnRefObject();
}
SetMaxNodeData( nil );
return true;
}
#include "plGetLocationDlg.h"
//
// Helper for setting synchedObject options, until we have a GUI
//
#include "../plResMgr/plKeyFinder.h"
#include "plMaxCFGFile.h"
#include "../plAgeDescription/plAgeDescription.h"
#include "../plResMgr/plPageInfo.h"
#include "../pnNetCommon/plSDLTypes.h"
void plMaxNode::CheckSynchOptions(plSynchedObject* so)
{
if (so)
{
//////////////////////////////////////////////////////////////////////////
// TEMP - remove
//
TSTR sdata,sdataList[128];
int i,num;
//
// check for LocalOnly or DontPersist props
//
if (gUserPropMgr.UserPropExists(this, "LocalOnly"))
so->SetLocalOnly(true); // disable net synching and persistence
else
if (gUserPropMgr.UserPropExists(this, "DontPersistAny")) // disable all types of persistence
so->SetSynchFlagsBit(plSynchedObject::kExcludeAllPersistentState);
else
{
if (gUserPropMgr.GetUserPropStringList(this, "DontPersist", num, sdataList))
{
for(i=0;i<num;i++)
so->AddToSDLExcludeList(sdataList[i]); // disable a type of persistence
}
}
//
// Check for Volatile prop
//
if (gUserPropMgr.UserPropExists(this, "VolatileAll")) // make all sdl types on this object Volatile
so->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
else
{
if (gUserPropMgr.GetUserPropStringList(this, "Volatile", num, sdataList))
{
for(i=0;i<num;i++)
so->AddToSDLVolatileList(sdataList[i]); // make volatile a type of persistence
}
}
bool tempOldOverride = (gUserPropMgr.UserPropExists(this, "OverrideHighLevelSDL") != 0);
//
// TEMP - remove
//////////////////////////////////////////////////////////////////////////
// If this object isn't in a global room, turn off sync flags
if ((!tempOldOverride && !GetOverrideHighLevelSDL()) && !GetLocation().IsReserved())
{
bool isDynSim = GetPhysicalProps()->GetGroup() == plSimDefs::kGroupDynamic;
bool hasPFC = false;
int count = NumAttachedComponents();
for (UInt32 x = 0; x < count; x++)
{
plComponentBase *comp = GetAttachedComponent(x);
if (comp->ClassID() == Class_ID(0x670d3629, 0x559e4f11))
{
hasPFC = true;
break;
}
}
if (!isDynSim && !hasPFC)
{
so->SetSynchFlagsBit(plSynchedObject::kExcludeAllPersistentState);
}
else
{
so->AddToSDLExcludeList(kSDLAGMaster);
so->AddToSDLExcludeList(kSDLResponder);
so->AddToSDLExcludeList(kSDLLayer);
so->AddToSDLExcludeList(kSDLSound);
so->AddToSDLExcludeList(kSDLXRegion);
}
}
}
}
hsBool plMaxNode::MakeSceneObject(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgName = GetName();
if (!CanConvert())
return false;
plLocation nodeLoc = GetLocation();//GetLocFromStrings(); // After this we can use GetLocation()
if (!nodeLoc.IsValid())
{
// If we are reconverting, we don't want to bother the user about a room.
// In most cases, if it doesn't have a room we are in the middle of creating
// it. We don't want to pop up a dialog at that point.
if (settings->fReconvert)
{
SetCanConvert(false);
return false;
}
if (!plGetLocationDlg::Instance().GetLocation(this, pErrMsg))
return false;
nodeLoc = GetLocation();
}
plSceneObject* pso;
plKey objKey;
// Handle this as a SceneObject
pso = TRACKED_NEW plSceneObject;
objKey = hsgResMgr::ResMgr()->NewKey(GetName(), pso, nodeLoc, GetLoadMask());
// Remember info in MaxNodeData block for later
plMaxNodeData *pDat = GetMaxNodeData();
pDat->SetKey(objKey);
pDat->SetSceneObject(pso);
CheckSynchOptions(pso);
return true;
}
hsBool plMaxNode::PrepareSkin(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !IFindBones(pErrMsg, settings) )
return false;
if( !NumBones() )
return true;
int i;
for( i = 0; i < NumBones(); i++ )
{
GetBone(i)->SetForceLocal(true);
GetBone(i)->SetDrawable(false);
}
return true;
}
hsBool plMaxNode::IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !CanConvert() )
return false;
if (UserPropExists("Bone"))
{
AddBone(this);
SetForceLocal(true);
}
ISkin* skin = FindSkinModifier();
if( skin && skin->GetNumBones() )
{
char *dbgNodeName = GetName();
// BoneUpdate
//SetForceLocal(true);
int i;
for( i = 0; i < skin->GetNumBones(); i++ )
{
plMaxNode* bone = (plMaxNode*)skin->GetBone(i);
if( bone )
{
if( !bone->CanConvert() || !bone->GetMaxNodeData() )
{
if( pErrMsg->Set(true, GetName(), "Trouble connecting to bone %s - skipping", bone->GetName()).CheckAndAsk() )
SetDrawable(false);
}
else
{
AddBone(bone);
bone->SetForceLocal(true);
}
}
else
{
if( pErrMsg->Set(true, GetName(), "Trouble finding bone - skipping").CheckAndAsk() )
SetDrawable(false);
}
}
}
return true;
}
#include "plMaxMeshExtractor.h"
#include "plPhysXCooking.h"
#include "../plPhysX/plPXStream.h"
#include "../plPhysX/plSimulationMgr.h"
#include "hsSTLStream.h"
hsBool plMaxNode::MakePhysical(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
if( !CanConvert() )
return false;
if( !GetPhysical() )
return true;
plPhysicalProps *physProps = GetPhysicalProps();
if (!physProps->IsUsed())
return true;
//hsStatusMessageF("Making phys for %s", dbgNodeName);
plSimDefs::Group group = (plSimDefs::Group)physProps->GetGroup();
plSimDefs::Bounds bounds = (plSimDefs::Bounds)physProps->GetBoundsType();
float mass = physProps->GetMass();
plMaxNode *proxyNode = physProps->GetProxyNode();
if (!proxyNode)
proxyNode = this;
// We want to draw solid physicals only. If it is something avatars bounce off,
// set it to drawable.
if (settings->fPhysicalsOnly)
{
if (group == plSimDefs::kGroupStatic ||
group == plSimDefs::kGroupAvatarBlocker ||
group == plSimDefs::kGroupDynamic)
proxyNode->SetDrawable(true);
}
// If mass is zero and we're animated, set the mass to 1 so it will get a rigid
// body. Otherwise PhysX will make assumptions about the physical which will
// fail when it gets moved.
if (physProps->GetPhysAnim() && mass == 0.f)
mass = 1.f;
TSTR sdata;
plMaxNode* baseNode = this;
while (!baseNode->GetParentNode()->IsRootNode())
baseNode = (plMaxNode*)baseNode->GetParentNode();
plKey roomKey = baseNode->GetRoomKey();
if (!roomKey)
{
pErrMsg->Set(true, "Room Processing Error - Physics" "The Room that physics component %s is attached to should have already been\nprocessed.", GetName());
return false;
}
plMaxNode* subworld = physProps->GetSubworld();
PhysRecipe recipe;
recipe.mass = mass;
recipe.friction = physProps->GetFriction();
recipe.restitution = physProps->GetRestitution();
recipe.bounds = (plSimDefs::Bounds)physProps->GetBoundsType();
recipe.group = group;
recipe.reportsOn = physProps->GetReportGroup();
recipe.objectKey = GetKey();
recipe.sceneNode = roomKey;
recipe.worldKey = subworld ? subworld->GetKey() : nil;
plMaxMeshExtractor::NeutralMesh mesh;
plMaxMeshExtractor::Extract(mesh, proxyNode, bounds == plSimDefs::kBoxBounds, this);
if (subworld)
recipe.l2s = subworld->GetWorldToLocal44() * mesh.fL2W;
else
recipe.l2s = mesh.fL2W;
switch (bounds)
{
case plSimDefs::kBoxBounds:
{
hsPoint3 minV(FLT_MAX, FLT_MAX, FLT_MAX), maxV(-FLT_MAX, -FLT_MAX, -FLT_MAX);
for (int i = 0; i < mesh.fNumVerts; i++)
{
minV.fX = hsMinimum(mesh.fVerts[i].fX, minV.fX);
minV.fY = hsMinimum(mesh.fVerts[i].fY, minV.fY);
minV.fZ = hsMinimum(mesh.fVerts[i].fZ, minV.fZ);
maxV.fX = hsMaximum(mesh.fVerts[i].fX, maxV.fX);
maxV.fY = hsMaximum(mesh.fVerts[i].fY, maxV.fY);
maxV.fZ = hsMaximum(mesh.fVerts[i].fZ, maxV.fZ);
}
hsPoint3 width = maxV - minV;
recipe.bDimensions = width / 2;
recipe.bOffset = minV + (width / 2.f);
}
break;
case plSimDefs::kProxyBounds:
case plSimDefs::kExplicitBounds:
{
// if this is a detector then try to convert to a convex hull first... if that doesn't succeed then do it as an exact
if ( group == plSimDefs::kGroupDetector )
{
// try converting to a convex hull mesh
recipe.meshStream = plPhysXCooking::CookHull(mesh.fNumVerts, mesh.fVerts,false);
if (recipe.meshStream)
{
plPXStream pxs(recipe.meshStream);
recipe.convexMesh = plSimulationMgr::GetInstance()->GetSDK()->createConvexMesh(pxs);
recipe.bounds = plSimDefs::kHullBounds;
// then test to see if the original mesh was convex (unless they said to skip 'em)
#ifdef WARNINGS_ON_CONCAVE_PHYSX_WORKAROUND
if ( !plPhysXCooking::fSkipErrors )
{
if ( !plPhysXCooking::TestIfConvex(recipe.convexMesh, mesh.fNumVerts, mesh.fVerts) )
{
int retStatus = pErrMsg->Set(true, "Physics Warning: PhysX workaround", "Detector region that is marked as exact and is concave but switching to convex hull for PhysX: %s", GetName()).CheckAskOrCancel();
pErrMsg->Set();
if ( retStatus == 1 ) // cancel?
plPhysXCooking::fSkipErrors = true;
}
}
#endif // WARNINGS_ON_CONCAVE_PHYSX_WORKAROUND
}
if (!recipe.meshStream)
{
if ( !pErrMsg->Set(true, "Physics Warning", "Detector region exact failed to be made a Hull, trying trimesh: %s", GetName()).Show() )
pErrMsg->Set();
recipe.meshStream = plPhysXCooking::CookTrimesh(mesh.fNumVerts, mesh.fVerts, mesh.fNumFaces, mesh.fFaces);
if (!recipe.meshStream)
{
pErrMsg->Set(true, "Physics Error", "Trimesh creation failed for physical %s", GetName()).Show();
return false;
}
plPXStream pxs(recipe.meshStream);
recipe.triMesh = plSimulationMgr::GetInstance()->GetSDK()->createTriangleMesh(pxs);
}
}
else
{
recipe.meshStream = plPhysXCooking::CookTrimesh(mesh.fNumVerts, mesh.fVerts, mesh.fNumFaces, mesh.fFaces);
if (!recipe.meshStream)
{
pErrMsg->Set(true, "Physics Error", "Trimesh creation failed for physical %s", GetName()).Show();
return false;
}
plPXStream pxs(recipe.meshStream);
recipe.triMesh = plSimulationMgr::GetInstance()->GetSDK()->createTriangleMesh(pxs);
}
}
break;
case plSimDefs::kSphereBounds:
{
hsPoint3 minV(FLT_MAX, FLT_MAX, FLT_MAX), maxV(-FLT_MAX, -FLT_MAX, -FLT_MAX);
for (int i = 0; i < mesh.fNumVerts; i++)
{
minV.fX = hsMinimum(mesh.fVerts[i].fX, minV.fX);
minV.fY = hsMinimum(mesh.fVerts[i].fY, minV.fY);
minV.fZ = hsMinimum(mesh.fVerts[i].fZ, minV.fZ);
maxV.fX = hsMaximum(mesh.fVerts[i].fX, maxV.fX);
maxV.fY = hsMaximum(mesh.fVerts[i].fY, maxV.fY);
maxV.fZ = hsMaximum(mesh.fVerts[i].fZ, maxV.fZ);
}
hsPoint3 width = maxV - minV;
recipe.radius = hsMaximum(width.fX, hsMaximum(width.fY, width.fZ));
recipe.radius /= 2.f;
recipe.offset = minV + (width / 2.f);
}
break;
case plSimDefs::kHullBounds:
{
if ( group == plSimDefs::kGroupDynamic )
{
recipe.meshStream = plPhysXCooking::IMakePolytope(mesh);
if (!recipe.meshStream)
{
pErrMsg->Set(true, "Physics Error", "polyTope-convexhull failed for physical %s", GetName()).Show();
return false;
}
}
else
{
recipe.meshStream = plPhysXCooking::CookHull(mesh.fNumVerts, mesh.fVerts,false);
if(!recipe.meshStream)
{
pErrMsg->Set(true, "Physics Error", "Convex hull creation failed for physical %s", GetName()).Show();
return false;
}
}
plPXStream pxs(recipe.meshStream);
recipe.convexMesh = plSimulationMgr::GetInstance()->GetSDK()->createConvexMesh(pxs);
}
break;
}
delete [] mesh.fFaces;
delete [] mesh.fVerts;
//
// Create the physical
//
plPXPhysical* physical = TRACKED_NEW plPXPhysical;
// add the object to the resource manager, keyed to the new name
plLocation nodeLoc = GetKey()->GetUoid().GetLocation();
const char *objName = GetKey()->GetName();
plKey physKey = hsgResMgr::ResMgr()->NewKey(objName, physical, nodeLoc, GetLoadMask());
if (!physical->Init(recipe))
{
pErrMsg->Set(true, "Physics Error", "Physical creation failed for object %s", GetName()).Show();
physKey->RefObject();
physKey->UnRefObject();
return false;
}
physical->SetProperty(plSimulationInterface::kPinned, physProps->GetPinned());
physical->SetProperty(plSimulationInterface::kPhysAnim, physProps->GetPhysAnim());
physical->SetProperty(plSimulationInterface::kNoSynchronize, (physProps->GetNoSynchronize() != 0));
physical->SetProperty(plSimulationInterface::kStartInactive, (physProps->GetStartInactive() != 0));
physical->SetProperty(plSimulationInterface::kAvAnimPushable, (physProps->GetAvAnimPushable() != 0));
if(physProps->GetLOSBlockCamera())
physical->AddLOSDB(plSimDefs::kLOSDBCameraBlockers);
if(physProps->GetLOSBlockUI())
physical->AddLOSDB(plSimDefs::kLOSDBUIBlockers);
if(physProps->GetLOSBlockCustom())
physical->AddLOSDB(plSimDefs::kLOSDBCustom);
if(physProps->GetLOSUIItem())
physical->AddLOSDB(plSimDefs::kLOSDBUIItems);
if(physProps->GetLOSShootable())
physical->AddLOSDB(plSimDefs::kLOSDBShootableItems);
if(physProps->GetLOSAvatarWalkable())
physical->AddLOSDB(plSimDefs::kLOSDBAvatarWalkable);
if(physProps->GetLOSSwimRegion())
physical->AddLOSDB(plSimDefs::kLOSDBSwimRegion);
plSimulationInterface* si = TRACKED_NEW plSimulationInterface;
plKey pSiKey = hsgResMgr::ResMgr()->NewKey(objName, si, nodeLoc, GetLoadMask());
// link the simulation interface to the scene object
hsgResMgr::ResMgr()->AddViaNotify(pSiKey, TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
// add the physical to the simulation interface
hsgResMgr::ResMgr()->AddViaNotify(physKey , TRACKED_NEW plIntRefMsg(pSiKey, plRefMsg::kOnCreate, 0, plIntRefMsg::kPhysical), plRefFlags::kActiveRef);
return true;
}
hsBool plMaxNode::MakeController(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
hsBool forceLocal = hsControlConverter::Instance().ForceLocal(this);
// Rember the force Local setting
hsBool CurrForceLocal = GetForceLocal(); // dont want to clobber it with false if componentPass made it true
forceLocal = (CurrForceLocal || forceLocal) ? true : false; // if it was set before, or is true now, make it true...
SetForceLocal(forceLocal);
if( IsTMAnimated() && (!GetParentNode()->IsRootNode()) )
{
((plMaxNode*)GetParentNode())->SetForceLocal(true);
}
return true;
}
hsBool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
if (!CanConvert())
return false;
plCoordinateInterface* ci = nil;
hsBool forceLocal = GetForceLocal();
hsBool needCI = (!GetParentNode()->IsRootNode())
|| NumberOfChildren()
|| forceLocal;
// If we have a transform, set up a coordinateinterface
if( needCI )
{
hsMatrix44 loc2Par = GetLocalToParent44();
hsMatrix44 par2Loc = GetParentToLocal44();
if( GetFilterInherit() )
ci = TRACKED_NEW plFilterCoordInterface;
else
ci = TRACKED_NEW plCoordinateInterface;
//-------------------------
// Get data from Node, then its key, then its name
//-------------------------
plKey pNodeKey = GetKey();
hsAssert(pNodeKey, "Missing key for this Object");
const char *pName = pNodeKey->GetName();
plLocation nodeLoc = GetLocation();
plKey pCiKey = hsgResMgr::ResMgr()->NewKey(pName, ci,nodeLoc, GetLoadMask());
ci->SetLocalToParent(loc2Par, par2Loc);
hsBool usesPhysics = GetPhysicalProps()->IsUsed();
ci->SetProperty(plCoordinateInterface::kCanEverDelayTransform, !usesPhysics);
ci->SetProperty(plCoordinateInterface::kDelayedTransformEval, !usesPhysics);
hsgResMgr::ResMgr()->AddViaNotify(pCiKey, TRACKED_NEW plObjRefMsg(pNodeKey, plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
}
return true;
}
hsBool plMaxNode::MakeModifiers(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
hsBool forceLocal = GetForceLocal();
const char *dbgNodeName = GetName();
hsBool addMods = (!GetParentNode()->IsRootNode())
|| forceLocal;
if (addMods)
{
// create / add modifiers
// mf horse hack testing ViewFace which is already obsolete
if ( UserPropExists("ViewFacing") )
{
plViewFaceModifier* pMod = TRACKED_NEW plViewFaceModifier;
if( UserPropExists("VFPivotFavorY") )
pMod->SetFlag(plViewFaceModifier::kPivotFavorY);
else if( UserPropExists("VFPivotY") )
pMod->SetFlag(plViewFaceModifier::kPivotY);
else if( UserPropExists("VFPivotTumble") )
pMod->SetFlag(plViewFaceModifier::kPivotTumble);
else
pMod->SetFlag(plViewFaceModifier::kPivotFace);
if( UserPropExists("VFScale") )
{
pMod->SetFlag(plViewFaceModifier::kScale);
TSTR sdata;
GetUserPropString("VFScale",sdata);
hsStringTokenizer toker;
toker.Reset(sdata, hsConverterUtils::fTagSeps);
int nGot = 0;
char* token;
hsVector3 scale;
scale.Set(1.f,1.f,1.f);
while( (nGot < 3) && (token = toker.next()) )
{
switch( nGot )
{
case 0:
scale.fZ = hsScalar(atof(token));
break;
case 1:
scale.fX = scale.fZ;
scale.fY = hsScalar(atof(token));
scale.fZ = 1.f;
break;
case 2:
scale.fZ = hsScalar(atof(token));
break;
}
nGot++;
}
pMod->SetScale(scale);
}
AddModifier(pMod, GetName());
}
}
return true;
}
hsBool plMaxNode::MakeParentOrRoomConnection(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
char *dbgNodeName = GetName();
plSceneObject *pso = GetSceneObject();
if( !GetParentNode()->IsRootNode() )
{
plKey parKey = GetParentKey();
plCoordinateInterface* ci = const_cast <plCoordinateInterface*> (pso->GetCoordinateInterface());
hsAssert(ci,"Missing CI");
plIntRefMsg* msg = TRACKED_NEW plIntRefMsg(parKey, plRefMsg::kOnCreate, -1, plIntRefMsg::kChildObject);
msg->SetRef(pso);
hsgResMgr::ResMgr()->AddViaNotify(msg, plRefFlags::kPassiveRef);
}
hsgResMgr::ResMgr()->AddViaNotify(pso->GetKey(), TRACKED_NEW plNodeRefMsg(GetRoomKey(), plRefMsg::kOnCreate, -1, plNodeRefMsg::kObject), plRefFlags::kActiveRef);
return true;
}
void plMaxNode::IWipeBranchDrawable(hsBool b)
{
SetDrawable(b);
for (int i = 0; i < NumberOfChildren(); i++)
{
plMaxNode *pChild = (plMaxNode *)GetChildNode(i);
pChild->IWipeBranchDrawable(b);
}
}
//// CanMakeMesh /////////////////////////////////////////////////////////////
// Returns true if MakeMesh() on this node will result in spans being stored
// on a drawable. Takes in the object pointer to avoid having to do redundant
// work to get it.
// 9.25.2001 mcn - Made public so components can figure out if this node is
// meshable.
hsBool plMaxNode::CanMakeMesh( Object *obj, plErrorMsg *pErrMsg, plConvertSettings *settings )
{
if( obj == nil )
return false;
if( UserPropExists( "Plasma2_Camera" ) )
return false;
if( !GetSwappableGeom() && !GetDrawable() )
return false;
if( GetParticleRelated() )
return false;
if( obj->CanConvertToType( triObjectClassID ) )
return true;
return false;
}
void ITestAdjacencyRecur(const hsTArray<int>* vertList, int iVert, hsBitVector& adjVerts)
{
adjVerts.SetBit(iVert);
int i;
for( i = 0; i < vertList[iVert].GetCount(); i++ )
{
if( !adjVerts.IsBitSet(vertList[iVert][i]) )
{
ITestAdjacencyRecur(vertList, vertList[iVert][i], adjVerts);
}
}
}
hsBool ITestAdjacency(const hsTArray<int>* vertList, int numVerts)
{
hsBitVector adjVerts;
ITestAdjacencyRecur(vertList, 0, adjVerts);
int i;
for( i = 0; i < numVerts; i++ )
{
if( !adjVerts.IsBitSet(i) )
return false;
}
return true;
}
int IsGeoSpanConvexExhaust(const plGeometrySpan* span)
{
// Brute force, check every point against every face
UInt16* idx = span->fIndexData;
int numFaces = span->fNumIndices / 3;
UInt32 stride = span->GetVertexSize(span->fFormat);
UInt8* vertData = span->fVertexData;
int numVerts = span->fNumVerts;
hsBool someIn = false;
hsBool someOut = false;
int i;
for( i = 0; i < numFaces; i++ )
{
// compute norm and dist for face
hsPoint3* pos[3];
pos[0] = (hsPoint3*)(vertData + idx[0] * stride);
pos[1] = (hsPoint3*)(vertData + idx[1] * stride);
pos[2] = (hsPoint3*)(vertData + idx[2] * stride);
hsVector3 edge01(pos[1], pos[0]);
hsVector3 edge02(pos[2], pos[0]);
hsVector3 faceNorm = edge01 % edge02;
hsFastMath::NormalizeAppr(faceNorm);
hsScalar faceDist = faceNorm.InnerProduct(pos[0]);
int j;
for( j = 0; j < numVerts; j++ )
{
hsPoint3* p = (hsPoint3*)(vertData + idx[0] * stride);
hsScalar dist = p->InnerProduct(faceNorm) - faceDist;
const hsScalar kSmall = 1.e-3f;
if( dist < -kSmall )
someIn = true;
else if( dist > kSmall )
someOut = true;
if( someIn && someOut )
return false;
}
idx += 3;
}
return true;
}
int IsGeoSpanConvex(plMaxNode* node, const plGeometrySpan* span)
{
static int skipTest = false;
if( skipTest )
return 0;
// May not be now, but could become.
if( span->fFormat & plGeometrySpan::kSkinWeightMask )
return 0;
// May not be now, but could become.
if( node->GetConcave() || node->UserPropExists("XXXWaterColor") )
return 0;
if( span->fMaterial && span->fMaterial->GetLayer(0) && (span->fMaterial->GetLayer(0)->GetMiscFlags() & hsGMatState::kMiscTwoSided) )
return 0;
int numVerts = span->fNumVerts;
if( !numVerts )
return 0;
int numFaces = span->fNumIndices / 3;
if( !numFaces )
return 0;
const int kSmallNumFaces = 20;
if( numFaces <= kSmallNumFaces )
return IsGeoSpanConvexExhaust(span);
hsTArray<int>* vertList = TRACKED_NEW hsTArray<int> [numVerts];
hsTArray<hsVector3>* normList = TRACKED_NEW hsTArray<hsVector3> [numVerts];
hsTArray<hsScalar>* distList = TRACKED_NEW hsTArray<hsScalar> [numVerts];
UInt16* idx = span->fIndexData;
UInt32 stride = span->GetVertexSize(span->fFormat);
UInt8* vertData = span->fVertexData;
// For each face
int iFace;
for( iFace = 0; iFace < numFaces; iFace++ )
{
// compute norm and dist for face
hsPoint3* pos[3];
pos[0] = (hsPoint3*)(vertData + idx[0] * stride);
pos[1] = (hsPoint3*)(vertData + idx[1] * stride);
pos[2] = (hsPoint3*)(vertData + idx[2] * stride);
hsVector3 edge01(pos[1], pos[0]);
hsVector3 edge02(pos[2], pos[0]);
hsVector3 faceNorm = edge01 % edge02;
hsFastMath::NormalizeAppr(faceNorm);
hsScalar faceDist = faceNorm.InnerProduct(pos[0]);
// For each vert
int iVtx;
for( iVtx = 0; iVtx < 3; iVtx++ )
{
int jVtx;
for( jVtx = 0; jVtx < 3; jVtx++ )
{
if( iVtx != jVtx )
{
// if idx[jVtx] not in list vertList[idx[iVtx]], add it
if( vertList[idx[iVtx]].kMissingIndex == vertList[idx[iVtx]].Find(idx[jVtx]) )
vertList[idx[iVtx]].Append(idx[jVtx]);
}
}
normList[idx[iVtx]].Append(faceNorm);
distList[idx[iVtx]].Append(faceDist);
}
idx += 3;
}
hsBool someIn = false;
hsBool someOut = false;
int i;
for( i = 0; i < numVerts; i++ )
{
int k;
for( k = 0; k < normList[i].GetCount(); k++ )
{
int j;
for( j = 0; j < vertList[i].GetCount(); j++ )
{
hsPoint3* pos = (hsPoint3*)(vertData + vertList[i][j] * stride);
hsScalar dist = pos->InnerProduct(normList[i][k]) - distList[i][k];
const hsScalar kSmall = 1.e-3f;
if( dist < -kSmall )
someIn = true;
else if( dist > kSmall )
someOut = true;
if( someIn && someOut )
goto cleanUp;
}
}
}
if( !ITestAdjacency(vertList, numVerts) )
someIn = someOut = true;
cleanUp:
delete [] vertList;
delete [] normList;
delete [] distList;
if( someIn && someOut )
return 0;
return someIn ? -1 : 1;
}
// Returns nil if there isn't a sceneobject and a drawinterface.
plDrawInterface* plMaxNode::GetDrawInterface()
{
plDrawInterface* di = nil;
plSceneObject* obj = GetSceneObject();
if( obj )
{
di = obj->GetVolatileDrawInterface();
}
return di;
}
hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
hsTArray<plGeometrySpan *> spanArray;
plDrawInterface *newDI = nil;
hsBool gotMade = false;
hsBool haveAddedToSceneNode = false;
hsGMesh *myMesh = nil;
UInt32 i, triMeshIndex = (UInt32)-1;
const char *dbgNodeName = GetName();
TSTR sdata;
hsStringTokenizer toker;
plLocation nodeLoc = GetLocation();
if (!GetSwappableGeom())
{
if (!CanConvert())
return false;
if( UserPropExists( "Plasma2_Camera" ) || !GetDrawable() )
{
SetMesh( nil );
return true;
}
}
if( GetSwappableGeomTarget() != (UInt32)-1)
{
// This node has no geometry on export, but will have some added at runtime,
// so it needs a special drawInterface
plInstanceDrawInterface *newDI = TRACKED_NEW plInstanceDrawInterface;
newDI->fTargetID = GetSwappableGeomTarget();
plKey pDiKey = hsgResMgr::ResMgr()->NewKey( GetKey()->GetName(), newDI, nodeLoc, GetLoadMask() );
hsgResMgr::ResMgr()->AddViaNotify(pDiKey, TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
plSwapSpansRefMsg *sMsg = TRACKED_NEW plSwapSpansRefMsg(pDiKey, plRefMsg::kOnCreate, -1, -1);
plDrawableSpans *drawable = IGetSceneNodeSpans(IGetDrawableSceneNode(pErrMsg), true, true);
hsgResMgr::ResMgr()->AddViaNotify(drawable->GetKey(), sMsg, plRefFlags::kActiveRef);
return true;
}
if( GetInstanced() )
{
hsTArray<plMaxNode *> nodes;
TimeValue t = hsConverterUtils::Instance().GetTime(GetInterface());
UInt32 numInstances = IBuildInstanceList( GetObjectRef(), t, nodes, true );
/// Instanced, find an iNode in the list that's been converted already
for( i = 0; i < numInstances; i++ )
{
if( nodes[ i ]->GetSceneObject() && nodes[ i ]->GetSceneObject()->GetDrawInterface() )
{
/// Found it!
if( !IMakeInstanceSpans( nodes[ i ], spanArray, pErrMsg, settings ) )
return false;
gotMade = true;
break;
}
}
/// If we didn't find anything, nothing's got converted yet, so convert the first one
/// like normal
}
// This has the side effect of calling SetMovable(true) if it should be and
// isn't already. So it needs to be before we make the mesh (and material).
// (Really, whatever makes it movable should do so then, but that has the potential
// to break other stuff, which I don't want to do 2 weeks before we ship).
hsBool movable = IsMovable();
if( !gotMade )
{
if( !plMeshConverter::Instance().CreateSpans( this, spanArray, !settings->fDoPreshade ) )
return false;
}
if( !spanArray.GetCount() )
return true;
for( i = 0; i < spanArray.GetCount(); i++ )
spanArray[i]->fMaxOwner = GetKey()->GetName();
UInt32 shadeFlags = 0;
if( GetNoPreShade() )
shadeFlags |= plGeometrySpan::kPropNoPreShade;
if( GetRunTimeLight() )
shadeFlags |= plGeometrySpan::kPropRunTimeLight;
if( GetNoShadow() )
shadeFlags |= plGeometrySpan::kPropNoShadow;
if( GetForceShadow() || GetAvatarSO() )
shadeFlags |= plGeometrySpan::kPropForceShadow;
if( GetReverseSort() )
shadeFlags |= plGeometrySpan::kPropReverseSort;
if( GetForceVisLOS() )
shadeFlags |= plGeometrySpan::kVisLOS;
if( shadeFlags )
{
for( i = 0; i < spanArray.GetCount(); i++ )
spanArray[ i ]->fProps |= shadeFlags;
}
hsBool DecalMat = false;
hsBool NonDecalMat = false;
for (i = 0; i < spanArray.GetCount(); i++)
{
if (spanArray[i]->fMaterial->IsDecal())
DecalMat = true;
else
NonDecalMat = true;
}
if (!(DecalMat ^ NonDecalMat))
{
for( i = 0; i < spanArray.GetCount(); i++ )
spanArray[ i ]->ClearBuffers();
if (pErrMsg->Set((plConvert::Instance().fWarned & plConvert::kWarnedDecalAndNonDecal) == 0, GetName(),
"This node has both regular and decal materials, and thus will be ignored.").CheckAskOrCancel())
{
plConvert::Instance().fWarned |= plConvert::kWarnedDecalAndNonDecal;
}
pErrMsg->Set(false);
return false;
}
hsBool isDecal = IsLegalDecal(false); // Don't complain about the parent
/// Get some stuff
hsBool forceLocal = GetForceLocal();
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
/// 4.17.2001 mcn - TEMP HACK to test fog by adding a key to a bogus fogEnviron object to ALL spans
/* plFogEnvironment *myFog = nil;
plKey myFogKey = hsgResMgr::ResMgr()->FindExportAlias( "HACK_FOG", plFogEnvironment::Index() );
if( myFogKey != nil )
myFog = plFogEnvironment::ConvertNoRef( myFogKey->GetObjectPtr() );
else
{
hsColorRGBA color;
color.Set( 0.5, 0.5, 1, 1 );
// Exp fog
myFog = TRACKED_NEW plFogEnvironment( plFogEnvironment::kExpFog, 700.f, 1.f, color );
myFogKey = hsgResMgr::ResMgr()->NewKey( "HACK_FOG", myFog, nodeLoc );
hsgResMgr::ResMgr()->AddExportAlias( "HACK_FOG", plFogEnvironment::Index(), myFogKey );
}
for( int j = 0; j < spanArray.GetCount(); j++ )
{
spanArray[ j ].fFogEnviron = myFog;
}
*/ /// 4.17.2001 mcn - TEMP HACK end
plDrawable* drawable = nil;
plSceneNode* tmpNode = nil;
/// Find the ice to add it to
if (GetSwappableGeom()) // We just want to make a geo span, not actually add it to a drawable(interface)
{
plMaxNode *drawableSource = (plMaxNode *)(GetParentNode()->IsRootNode() ? this : GetParentNode());
plSceneNode *tmpNode = drawableSource->IGetDrawableSceneNode(pErrMsg);
plDrawableSpans *drawable = IGetSceneNodeSpans(tmpNode, true, true);
ISetupBones(drawable, spanArray, l2w, w2l, pErrMsg, settings);
hsTArray<plGeometrySpan *> *swapSpans = &GetSwappableGeom()->fSpans;
for (i = 0; i < spanArray.GetCount(); i++)
swapSpans->Append(spanArray.Get(i));
char tmpName[256];
sprintf(tmpName, "%s_SMsh", GetName());
hsgResMgr::ResMgr()->NewKey(tmpName, GetSwappableGeom(), GetLocation(), GetLoadMask());
return true;
}
plMaxNode *nonDecalParent = this;
if( GetRoomKey() )
{
tmpNode = plSceneNode::ConvertNoRef( GetRoomKey()->GetObjectPtr() );
if (isDecal) // If we're a decal, we just want to use our parent's drawable
{
plMaxNode *parent = (plMaxNode *)GetParentNode();
SetDecalLevel(parent->GetDecalLevel() + 1);
for( i = 0; i < spanArray.GetCount(); i++ )
spanArray[ i ]->fDecalLevel = GetDecalLevel();
}
{
/// Make a new drawInterface (will assign stuff to it later)
newDI = TRACKED_NEW plDrawInterface;
plKey pDiKey = hsgResMgr::ResMgr()->NewKey( GetKey()->GetName(), newDI, nodeLoc, GetLoadMask() );
hsgResMgr::ResMgr()->AddViaNotify(pDiKey, TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
/// Attach the processed spans to the DI (through drawables)
IAssignSpansToDrawables( spanArray, newDI, pErrMsg, settings );
}
}
return true;
}
plSceneNode *plMaxNode::IGetDrawableSceneNode(plErrorMsg *pErrMsg)
{
plSceneNode *sn = nil;
sn = plSceneNode::ConvertNoRef( GetRoomKey()->GetObjectPtr() );
return sn;
}
//// IAssignSpansToDrawables /////////////////////////////////////////////////
// Given a span array, adds it to the node's drawables, creating them if
// necessary. Then it takes the resulting indices and drawable pointers
// and assigns them to the given drawInterface.
void plMaxNode::IAssignSpansToDrawables( hsTArray<plGeometrySpan *> &spanArray, plDrawInterface *di,
plErrorMsg *pErrMsg, plConvertSettings *settings )
{
hsTArray<plGeometrySpan *> opaqueArray, blendingArray, sortingArray;
plDrawableSpans *oSpans = nil, *bSpans = nil, *sSpans = nil;
int sCount, oCount, bCount, i;
plSceneNode *tmpNode = nil;
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
UInt32 oIndex = (UInt32)-1, bIndex = (UInt32)-1, sIndex = UInt32(-1);
tmpNode = IGetDrawableSceneNode(pErrMsg);
/*
/// Get sceneNode. If we're itinerant and not the parent node, this won't just
/// be GetRoomKey()->GetObjectPtr()....
if( GetItinerant() && !GetParentNode()->IsRootNode() )
{
/// Step up to the top of the chain
plMaxNode *baseNode = this;
while( !baseNode->GetParentNode()->IsRootNode() )
baseNode = (plMaxNode *)baseNode->GetParentNode();
if( baseNode->GetItinerant() )
tmpNode = plSceneNode::ConvertNoRef( baseNode->GetRoomKey()->GetObjectPtr() );
else
{
tmpNode = plSceneNode::ConvertNoRef( GetRoomKey()->GetObjectPtr() );
/// Warn, since we should only be itinerant if our parent is as well
pErrMsg->Set( true, "Warning", "Itinerant flag in child '%s' of non-itinerant tree. This should never happen. You should inform a programmer...", GetName() ).Show();
}
}
else
tmpNode = plSceneNode::ConvertNoRef( GetRoomKey()->GetObjectPtr() );
*/
hsBitVector convexBits;
/// Separate the array into two arrays, one opaque and one blending
for( sCount = 0, oCount = 0, bCount = 0, i = 0; i < spanArray.GetCount(); i++ )
{
if( spanArray[ i ]->fProps & plGeometrySpan::kRequiresBlending )
{
hsBool needFaceSort = !GetNoFaceSort() && !IsGeoSpanConvex(this, spanArray[i]);
if( needFaceSort )
{
sCount++;
}
else
{
convexBits.SetBit(i);
bCount++;
}
}
else
oCount++;
}
// Done this way, since expanding an hsTArray has the nasty side effect of just copying data, which we don't
// want when we have memory pointers...
opaqueArray.SetCount( oCount );
blendingArray.SetCount( bCount );
sortingArray.SetCount( sCount );
for( sCount = 0, oCount = 0, bCount = 0, i = 0; i < spanArray.GetCount(); i++ )
{
if( spanArray[ i ]->fProps & plGeometrySpan::kRequiresBlending )
{
if( convexBits.IsBitSet(i) )
blendingArray[ bCount++ ] = spanArray[ i ];
else
sortingArray [ sCount++ ] = spanArray[ i ];
}
else
opaqueArray[ oCount++ ] = spanArray[ i ];
}
/// Get some drawable pointers
if( opaqueArray.GetCount() > 0 )
oSpans = plDrawableSpans::ConvertNoRef( IGetSceneNodeSpans( tmpNode, false ) );
if( blendingArray.GetCount() > 0 )
bSpans = plDrawableSpans::ConvertNoRef( IGetSceneNodeSpans( tmpNode, true, false ) );
if( sortingArray.GetCount() > 0 )
sSpans = plDrawableSpans::ConvertNoRef( IGetSceneNodeSpans( tmpNode, true, true ) );
if( oSpans != nil )
IAssignSpan( oSpans, opaqueArray, oIndex, l2w, w2l, pErrMsg, settings );
if( bSpans != nil )
IAssignSpan( bSpans, blendingArray, bIndex, l2w, w2l, pErrMsg, settings );
if( sSpans )
IAssignSpan( sSpans, sortingArray, sIndex, l2w, w2l, pErrMsg, settings );
/// Now assign to the interface
if( oSpans )
{
UInt8 iDraw = di->GetNumDrawables();
di->SetDrawable( iDraw, oSpans );
di->SetDrawableMeshIndex( iDraw, oIndex );
}
if( bSpans )
{
UInt8 iDraw = di->GetNumDrawables();
di->SetDrawable( iDraw, bSpans );
di->SetDrawableMeshIndex( iDraw, bIndex );
}
if( sSpans )
{
UInt8 iDraw = di->GetNumDrawables();
di->SetDrawable( iDraw, sSpans );
di->SetDrawableMeshIndex( iDraw, sIndex );
}
}
//// IAssignSpan /////////////////////////////////////////////////////////////
// Small utility function for IAssignSpansToDrawables, just does some of
// the low-down work that's identical for each drawable/spans/etc.
void plMaxNode::IAssignSpan( plDrawableSpans *drawable, hsTArray<plGeometrySpan *> &spanArray, UInt32 &index,
hsMatrix44 &l2w, hsMatrix44 &w2l,
plErrorMsg *pErrMsg, plConvertSettings *settings )
{
if( NumBones() )
ISetupBones( drawable, spanArray, l2w, w2l, pErrMsg, settings );
// Assign spans to the drawables, plus set the volatile flag on the
// drawables for the SceneViewer, just in case it hasn't been set yet
if( settings->fSceneViewer )
{
drawable->SetNativeProperty( plDrawable::kPropVolatile, true );
index = drawable->AppendDISpans( spanArray, index, false );
}
else
index = drawable->AddDISpans( spanArray, index );
if( GetItinerant() )
drawable->SetNativeProperty(plDrawable::kPropCharacter, true);
}
// Tiny helper for the function below
void SetSpansBoneInfo(hsTArray<plGeometrySpan *> &spanArray, UInt32 baseMatrix, UInt32 numMatrices)
{
int i;
for( i = 0; i < spanArray.GetCount(); i++ )
{
spanArray[ i ]->fBaseMatrix = baseMatrix;
spanArray[ i ]->fNumMatrices = numMatrices;
}
}
//// ISetupBones /////////////////////////////////////////////////////////////
// Adds the given bones to the given drawable, then sets up the given spans
// with the right indices and sets the initial bone positions.
void plMaxNode::ISetupBones(plDrawableSpans *drawable, hsTArray<plGeometrySpan *> &spanArray,
hsMatrix44 &l2w, hsMatrix44 &w2l,
plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
if( !NumBones() )
return;
plMaxBoneMap *boneMap = GetBoneMap();
if (boneMap && boneMap->GetBaseMatrixIndex(drawable) != (UInt32)-1)
{
SetSpansBoneInfo(spanArray, boneMap->GetBaseMatrixIndex(drawable), boneMap->fNumBones);
return;
}
int baseMatrix, i;
UInt8 numBones = (boneMap ? boneMap->fNumBones : NumBones()) + 1;
plMaxNodeBase **boneArray = TRACKED_NEW plMaxNodeBase*[numBones];
if (boneMap)
boneMap->FillBoneArray(boneArray);
else
{
for (i = 0; i < NumBones(); i++)
{
boneArray[i] = GetBone(i);
}
}
hsTArray<hsMatrix44> initialB2W;
hsTArray<hsMatrix44> initialW2B;
initialB2W.SetCount(numBones);
initialW2B.SetCount(numBones);
hsTArray<hsMatrix44> initialL2B;
hsTArray<hsMatrix44> initialB2L;
initialL2B.SetCount(numBones);
initialB2L.SetCount(numBones);
initialB2W[0].Reset();
initialW2B[0].Reset();
initialL2B[0].Reset();
initialB2L[0].Reset();
for( i = 1; i < numBones; i++ )
{
hsMatrix44 b2w;
hsMatrix44 w2b;
hsMatrix44 l2b;
hsMatrix44 b2l;
plMaxNodeBase *bone = boneArray[i-1];
const char* dbgBoneName = bone->GetName();
Matrix3 localTM = bone->GetNodeTM(TimeValue(0));
b2w = Matrix3ToMatrix44(localTM);
b2w.GetInverse(&w2b);
l2b = w2b * l2w;
b2l = w2l * b2w;
initialB2W[i] = b2w;
initialW2B[i] = w2b;
initialL2B[i] = l2b;
initialB2L[i] = b2l;
}
// First, see if the bones are already set up appropriately.
// Appropriately means:
// a) Associated with the correct drawable (maybe others too, we don't care).
// b) InitialBone transforms match. If we (or another user of the same bone)
// are force localed, Our InitialBone won't match, because it also includes
// our transform as well as the bone's. If we've been flattened into world
// space, our transform is ident and we can share. This is the normal case
// in scene boning. So InitialBones have to match in count and matrix value.
baseMatrix = drawable->FindBoneBaseMatrix(initialL2B, GetSwappableGeom() != nil);
if( baseMatrix != UInt32(-1) )
{
SetSpansBoneInfo(spanArray, baseMatrix, numBones);
delete [] boneArray;
return;
}
baseMatrix = drawable->AppendDIMatrixSpans(numBones);
SetSpansBoneInfo(spanArray, baseMatrix, numBones);
if (boneMap)
boneMap->SetBaseMatrixIndex(drawable, baseMatrix);
for( i = 1; i < numBones; i++ )
{
plMaxNodeBase *bone = boneArray[i-1];
plSceneObject* obj = bone->GetSceneObject();
const char *dbgBoneName = bone->GetName();
// Pick which drawable to point the DI to
UInt8 iDraw = 0;
/// Now create the actual bone DI, or grab it if it's already created
plDrawInterface *di = obj->GetVolatileDrawInterface();
if( di )
{
for( iDraw = 0; iDraw < di->GetNumDrawables(); iDraw++ )
{
if( di->GetDrawable(iDraw) == drawable )
break;
}
}
else
{
plLocation nodeLoc = bone->GetLocation();
di = TRACKED_NEW plDrawInterface;
plKey diKey = hsgResMgr::ResMgr()->NewKey(GetKey()->GetName(), di, nodeLoc, GetLoadMask());
hsgResMgr::ResMgr()->AddViaNotify(diKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, 0, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
}
if( di->GetNumDrawables() <= iDraw )
{
UInt32 diIndex = drawable->NewDIMatrixIndex();
di->SetDrawableMeshIndex(iDraw, diIndex);
di->SetDrawable(iDraw, drawable);
}
plDISpanIndex& skinIndices = drawable->GetDISpans(di->GetDrawableMeshIndex(iDraw));
skinIndices.Append(baseMatrix + i);
drawable->SetInitialBone(baseMatrix + i, initialL2B[i], initialB2L[i]);
di->SetTransform(initialB2W[i], initialW2B[i]);
}
delete [] boneArray;
}
//// IMakeInstanceSpans //////////////////////////////////////////////////////
// Given an instance node, instances the geoSpans that the node owns and
// stores them in the given array.
hsBool plMaxNode::IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan *> &spanArray,
plErrorMsg *pErrMsg, plConvertSettings *settings )
{
UInt8 iDraw;
int index, i;
plSceneObject *obj = node->GetSceneObject();
if( !obj )
return false;
const plDrawInterface *di = obj->GetDrawInterface();
if( !di )
return false;
hsBool setVisDists = false;
hsScalar minDist, maxDist;
if( hsMaterialConverter::HasVisDists(this, 0, minDist, maxDist) )
{
setVisDists = true;
}
index = 0;
spanArray.Reset();
for( iDraw = 0; iDraw < di->GetNumDrawables(); iDraw++ )
{
plDrawableSpans* dr = plDrawableSpans::ConvertNoRef(di->GetDrawable(iDraw));
if( !dr )
continue;
if( di->GetDrawableMeshIndex(iDraw) == (UInt32)-1 )
continue;
plDISpanIndex disi = dr->GetDISpans(di->GetDrawableMeshIndex(iDraw));
spanArray.ExpandAndZero( spanArray.GetCount() + disi.fIndices.GetCount() );
for( i = 0; i < disi.fIndices.GetCount(); i++ )
{
spanArray[ index ] = TRACKED_NEW plGeometrySpan;
spanArray[ index ]->MakeInstanceOf( dr->GetGeometrySpan( disi.fIndices[ i ] ) );
if( setVisDists )
{
spanArray[ index ]->fMinDist = (minDist);
spanArray[ index ]->fMaxDist = (maxDist);
}
dr->GetGeometrySpan(disi.fIndices[i])->fProps |= plGeometrySpan::kInstanced;
spanArray[ index++ ]->fProps |= plGeometrySpan::kInstanced;
}
}
// Now that we have all of our instanced spans, we need to make sure we
// have the right materials. Why? There are some isolated cases (such as when "force
// material copy" is set) where we want to still instance the geometry but we want
// separate materials. In this case, GetMaterialArray() will return the right array of
// materials for our instanced node. However, since we've tossed everything except the
// final plGeometrySpans from MakeMesh(), we have to do a reverse lookup to see what
// materials get assigned to whom. GetMaterialArray() is guaranteed (according to Bob)
// to return materials in the same order for instanced nodes, so what we do is call
// GMA() for the old node and the new node (the old one should just be a lookup), then
// for each geoSpan look its old material up in the old array, find the matching material
// in the new array (i.e. same position) and assign that new material to the span.
#if 1 // Change this to 0 to just always use the same materials on instances (old, incorrect way)
Mtl *newMtl = GetMtl(), *origMtl = node->GetMtl();
if( newMtl != nil && newMtl == origMtl ) // newMtl should == origMtl, but check just in case
{
hsTArray<hsGMaterial *> oldMaterials, newMaterials;
if( hsMaterialConverter::IsMultiMat( newMtl ) )
{
for( i = 0; i < newMtl->NumSubMtls(); i++ )
{
hsMaterialConverter::Instance().GetMaterialArray( origMtl->GetSubMtl( i ), node, oldMaterials );
hsMaterialConverter::Instance().GetMaterialArray( newMtl->GetSubMtl( i ), this, newMaterials );
}
}
else
{
hsMaterialConverter::Instance().GetMaterialArray( origMtl, node, oldMaterials );
hsMaterialConverter::Instance().GetMaterialArray( newMtl, this, newMaterials );
}
/// Now we have two arrays to let us map, so walk through our geoSpans and translate them!
/// The good thing is that this is all done before the spans are added to the drawable,
/// so we don't have to worry about reffing or unreffing or any of that messiness; all of
/// that will be done for us as part of the normal AppendDISpans() process.
for( i = 0; i < spanArray.GetCount(); i++ )
{
int j;
// Find the span's original material
for( j = 0; j < oldMaterials.GetCount(); j++ )
{
if( spanArray[ i ]->fMaterial == oldMaterials[ j ] )
{
spanArray[ i ]->fMaterial = newMaterials[ j ];
break;
}
}
}
}
#endif
return true;
}
//// IBuildInstanceList //////////////////////////////////////////////////////
// For the given object, builds a list of all the iNodes that have that
// object as their object. Returns the total node count
UInt32 plMaxNode::IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, hsBool beMoreAccurate )
{
Object *thisObj = EvalWorldState( t ).obj;
DependentIterator di( obj );
ReferenceMaker *rm;
plMaxNode *node;
plKey sceneNodeKey = GetRoomKey();
/// Use the DependentIterator to loop through all the dependents of the object,
/// looking for nodes that use it
nodes.Reset();
while( rm = di.Next() )
{
if( rm->SuperClassID() == BASENODE_CLASS_ID )
{
node = (plMaxNode *)rm;
if( node->EvalWorldState( t ).obj == thisObj )
{
// Note: we CANNOT instance across pages (i.e. sceneNodes), so we need to make sure this
// INode will be in the same page as our master object
// Also note: RoomKeys will be nil until we've finished the first component pass, so when
// we test this in ConvertValidate(), the keys will be nil and all objects will be "in the
// same room", even though they're not. This is not too bad, though, since the worst that
// could happen is the object gets forced local even when there ends up not being any other
// instances of it in the same page. Ooooh.
if( sceneNodeKey == node->GetRoomKey() )
{
// Make sure the materials generated for both of these nodes will be the same
if( IMaterialsMatch( node, beMoreAccurate ) )
nodes.Append( node );
}
}
}
}
return nodes.GetCount();
}
//// IMaterialsMatch /////////////////////////////////////////////////////////
// Given two nodes that are instances of each other, this function determines
// whether the resulting exported materials for both will be the same or not.
// If not, we need to not instance/share the geometry, since the UV channels
// could (and most likely will) be different.
// To test this, all we really need to do is check the return values of
// AlphaHackLayersNeeded(), since all the other material parameters will be
// identical due to these nodes being instances of each other.
hsBool plMaxNode::IMaterialsMatch( plMaxNode *otherNode, hsBool beMoreAccurate )
{
Mtl *mtl = GetMtl(), *otherMtl = otherNode->GetMtl();
if( mtl != otherMtl )
return false; // The two objects have different materials, no way we
// can try to instance them now
if( mtl == nil )
return true; // Both nodes have no material, works for me
// If we're not told to be accurate, then we just quit here. This is because
// in the early passes, we *can't* be more accurate, since we won't have all
// the info yet, so we don't bother checking it
if( !beMoreAccurate )
return true;
if( hsMaterialConverter::IsMultiMat( mtl ) )
{
int i;
for( i = 0; i < mtl->NumSubMtls(); i++ )
{
if( AlphaHackLayersNeeded( i ) != otherNode->AlphaHackLayersNeeded( i ) )
return false;
}
}
else
{
if( AlphaHackLayersNeeded( -1 ) != otherNode->AlphaHackLayersNeeded( -1 ) )
return false;
}
// They're close enough!
return true;
}
hsBool plMaxNode::ShadeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
hsTArray<plGeometrySpan *> spanArray;
if( !(CanConvert() && GetDrawable()) )
return true;
plSceneObject* obj = GetSceneObject();
if( !obj )
return true;
const plDrawInterface* di = obj->GetDrawInterface();
if( !di )
return true;
UInt8 iDraw;
for( iDraw = 0; iDraw < di->GetNumDrawables(); iDraw++ )
{
plDrawableSpans* dr = plDrawableSpans::ConvertNoRef(di->GetDrawable(iDraw));
if( !dr )
continue;
if( di->GetDrawableMeshIndex(iDraw) == (UInt32)-1 )
continue;
plDISpanIndex disi = dr->GetDISpans(di->GetDrawableMeshIndex(iDraw));
int i;
for( i = 0; i < disi.fIndices.GetCount(); i++ )
{
spanArray.Append( dr->GetGeometrySpan( disi.fIndices[ i ] ) );
}
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
/// Shade the spans now
// Either do vertex shading or generate a light map.
if( GetLightMapComponent() )
{
plLightMapGen::Instance().MakeMaps(this, l2w, w2l, spanArray, pErrMsg, nil);
// Since they were already pointers to the geometry spans, we don't have
// to re-stuff them. Horray!
}
else
{
hsVertexShader::Instance().ShadeNode(this, l2w, w2l, spanArray);
}
if (settings && settings->fSceneViewer)
dr->RefreshDISpans(di->GetDrawableMeshIndex(iDraw));
}
return true;
}
hsBool plMaxNode::MakeOccluder(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !UserPropExists("Occluder") )
return true;
hsBool twoSided = UserPropExists("OccTwoSided");
hsBool isHole = UserPropExists("OccHole");
return ConvertToOccluder(pErrMsg, twoSided, isHole);
}
static void IRemoveCollinearPoints(hsTArray<Point3>& facePts)
{
int i;
for( i = 0; i < facePts.GetCount(); )
{
int j = i + 1 >= facePts.GetCount() ? 0 : i + 1;
int k = j + 1 >= facePts.GetCount() ? 0 : j + 1;
Point3 ab = FNormalize(facePts[i] - facePts[j]);
Point3 bc = FNormalize(facePts[j] - facePts[k]);
const float kDotCutoff = 1.f - 1.e-3f;
float dot = DotProd(ab, bc);
if( (dot < kDotCutoff) && (dot > -kDotCutoff) )
{
i++;
}
else
{
facePts.Remove(j);
}
}
}
hsBool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, hsBool twoSided, hsBool isHole)
{
if( !CanConvert() )
return false;
/// Get some stuff
plLocation nodeLoc = GetLocation();
hsBool moving = IsMovable();
if( moving )
moving++;
Matrix3 tmp(true);
Matrix3 maxL2V = GetLocalToVert(TimeValue(0));
Matrix3 maxV2L = GetVertToLocal(TimeValue(0));
hsTArray<plCullPoly> polys;
UInt32 polyInitFlags = plCullPoly::kNone;
if( isHole )
polyInitFlags |= plCullPoly::kHole;
else
if( twoSided )
polyInitFlags |= plCullPoly::kTwoSided;
Object *obj = EvalWorldState(TimeValue(0)).obj;
if( obj->CanConvertToType(triObjectClassID) )
{
TriObject *meshObj = (TriObject *)obj->ConvertToType(TimeValue(0), triObjectClassID);
if( meshObj )
{
Mesh mesh(meshObj->mesh);
const float kNormThresh = hsScalarPI / 20.f;
const float kEdgeThresh = hsScalarPI / 20.f;
const float kBias = 0.1f;
const float kMaxEdge = -1.f;
const DWORD kOptFlags = OPTIMIZE_SAVESMOOTHBOUNDRIES;
mesh.Optimize(
kNormThresh, // threshold of normal differences to preserve
kEdgeThresh, // When the angle between adjacent surface normals is less than this value the auto edge is performed (if the OPTIMIZE_AUTOEDGE flag is set). This angle is specified in radians.
kBias, // Increasing the bias parameter keeps triangles from becoming degenerate. range [0..1] (0 = no bias).
kMaxEdge, // This will prevent the optimize function from creating edges longer than this value. If this parameter is <=0 no limit is placed on the length of the edges.
kOptFlags, // Let them input using smoothing groups, but nothing else.
NULL); // progress bar
MNMesh mnMesh(mesh);
mnMesh.EliminateCollinearVerts();
mnMesh.EliminateCoincidentVerts(0.1f);
// Documentation recommends MakeConvexPolyMesh over MakePolyMesh. Naturally, MakePolyMesh works better.
// mnMesh.MakeConvexPolyMesh();
mnMesh.MakePolyMesh();
mnMesh.MakeConvex();
// mnMesh.MakePlanar(1.f * hsScalarPI / 180.f); // Completely ineffective. Winding up with majorly non-planar polys.
mnMesh.Transform(maxV2L);
polys.SetCount(mesh.getNumFaces());
polys.SetCount(0);
// Unfortunate problem here. Max is assuming that eventually this will get rendered, and so
// we need to avoid T-junctions. Fact is, T-junctions don't bother us at all, where-as colinear
// verts within a poly do (just as added overhead).
// So, to make this as painless (ha ha) as possible, we could detach each poly as we go to
// its own mnMesh, then eliminate colinear verts on that single poly mesh. Except
// EliminateCollinearVerts doesn't seem to actually do that. So we'll just have to
// manually detect and skip collinear verts.
hsTArray<Point3> facePts;
int i;
for( i = 0; i < mnMesh.numf; i++ )
{
MNFace& face = mnMesh.f[i];
facePts.SetCount(0);
int j;
for( j = 0; j < face.deg; j++ )
{
facePts.Append(mnMesh.v[face.vtx[j]].p);
}
IRemoveCollinearPoints(facePts);
if( facePts.GetCount() < 3 )
continue;
int lastAdded = 2;
plCullPoly* poly = polys.Push();
poly->fVerts.SetCount(0);
Point3 p;
hsPoint3 pt;
p = facePts[0];
pt.Set(p.x, p.y, p.z);
poly->fVerts.Append(pt);
p = facePts[1];
pt.Set(p.x, p.y, p.z);
poly->fVerts.Append(pt);
p = facePts[2];
pt.Set(p.x, p.y, p.z);
poly->fVerts.Append(pt);
for( j = lastAdded+1; j < facePts.GetCount(); j++ )
{
p = facePts[j];
pt.Set(p.x, p.y, p.z);
hsVector3 a = hsVector3(&pt, &poly->fVerts[0]);
hsVector3 b = hsVector3(&poly->fVerts[lastAdded], &poly->fVerts[0]);
hsVector3 c = hsVector3(&poly->fVerts[lastAdded-1], &poly->fVerts[0]);
hsVector3 aXb = a % b;
hsVector3 bXc = b % c;
hsFastMath::Normalize(aXb);
hsFastMath::Normalize(bXc);
hsScalar dotSq = aXb.InnerProduct(bXc);
dotSq *= dotSq;
const hsScalar kMinLenSq = 1.e-8f;
const hsScalar kMinDotFracSq = 0.998f * 0.998f;
hsScalar lenSq = aXb.MagnitudeSquared() * bXc.MagnitudeSquared();
if( lenSq < kMinLenSq )
continue;
// If not planar, move to new poly.
if( dotSq < lenSq * kMinDotFracSq )
{
poly->InitFromVerts(polyInitFlags);
poly = polys.Push();
plCullPoly* lastPoly = &polys[polys.GetCount()-2];
poly->fVerts.SetCount(0);
poly->fVerts.Append(lastPoly->fVerts[0]);
poly->fVerts.Append(lastPoly->fVerts[lastAdded]);
lastAdded = 1;
}
poly->fVerts.Append(pt);
lastAdded++;
}
poly->InitFromVerts(polyInitFlags);
}
}
}
if( polys.GetCount() )
{
plOccluder* occ = nil;
plMobileOccluder* mob = nil;
if( moving )
{
mob = TRACKED_NEW plMobileOccluder;
occ = mob;
}
else
{
occ = TRACKED_NEW plOccluder;
}
occ->SetPolyList(polys);
occ->ComputeFromPolys();
// Register it.
char tmpName[256];
if( GetKey() && GetKey()->GetName() && *GetKey()->GetName() )
{
sprintf(tmpName, "%s_%s", GetKey()->GetName(), "Occluder");
}
else
{
static int numOcc = 0;
sprintf(tmpName, "%s_%4.4d", "Occluder", numOcc);
}
plKey key = hsgResMgr::ResMgr()->NewKey( tmpName, occ, nodeLoc, GetLoadMask() );
hsgResMgr::ResMgr()->AddViaNotify(occ->GetKey(), TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
}
return true;
}
hsBool plMaxNode::MakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
if (!GetRunTimeLight())
return true;
/// Get some stuff
plLocation nodeLoc = GetLocation();
hsBool forceLocal = GetForceLocal();
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
hsMatrix44 lt2l = GetVertToLocal44();
hsMatrix44 l2lt = GetLocalToVert44();
plLightInfo* liInfo = nil;
liInfo = IMakeLight(pErrMsg, settings);
if( liInfo )
{
// 12.03.01 mcn - Um, we want RT lights to affect static objects if they're animated. So
// why wasn't this here a long time ago? :~
if( IsMovable() || IsAnimatedLight() )
liInfo->SetProperty(plLightInfo::kLPMovable, true);
liInfo->SetTransform(l2w, w2l);
liInfo->SetLocalToLight(l2lt, lt2l);
plKey key = hsgResMgr::ResMgr()->NewKey( GetKey()->GetName(), liInfo, nodeLoc, GetLoadMask() );
hsgResMgr::ResMgr()->AddViaNotify(liInfo->GetKey(), TRACKED_NEW plObjRefMsg(GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kInterface), plRefFlags::kActiveRef);
// Only support projection for spots and dir lights for now.
if( plLimitedDirLightInfo::ConvertNoRef(liInfo) || plSpotLightInfo::ConvertNoRef(liInfo) )
{
// Have to do this after the drawable gets a key.
IGetProjection(liInfo, pErrMsg);
}
}
return true;
}
plLightInfo* plMaxNode::IMakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
plLightInfo* liInfo = nil;
Object *obj = EvalWorldState(timeVal).obj;
if( obj->ClassID() == Class_ID(OMNI_LIGHT_CLASS_ID, 0) )
liInfo = IMakeOmni(pErrMsg, settings);
else
if( (obj->ClassID() == Class_ID(SPOT_LIGHT_CLASS_ID, 0)) || (obj->ClassID() == Class_ID(FSPOT_LIGHT_CLASS_ID, 0)) )
liInfo = IMakeSpot(pErrMsg, settings);
else
if( (obj->ClassID() == Class_ID(DIR_LIGHT_CLASS_ID, 0)) || (obj->ClassID() == Class_ID(TDIR_LIGHT_CLASS_ID, 0)) )
liInfo = IMakeDirectional(pErrMsg, settings);
else
if( obj->ClassID() == RTOMNI_LIGHT_CLASSID )
liInfo = IMakeRTOmni(pErrMsg, settings);
else
if( (obj->ClassID() == RTSPOT_LIGHT_CLASSID) ) //|| (obj->ClassID() == Class_ID(FSPOT_LIGHT_CLASS_ID, 0)) )
liInfo = IMakeRTSpot(pErrMsg, settings);
else
if( (obj->ClassID() == RTDIR_LIGHT_CLASSID) ) //|| (obj->ClassID() == Class_ID(FSPOT_LIGHT_CLASS_ID, 0)) )
liInfo = IMakeRTDirectional(pErrMsg, settings);
else
if( obj->ClassID() == RTPDIR_LIGHT_CLASSID )
liInfo = IMakeRTProjDirectional( pErrMsg, settings );
return liInfo;
}
void plMaxNode::IGetLightAttenuation(plOmniLightInfo* liInfo, LightObject* light, LightState& ls)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
hsScalar attenConst, attenLinear, attenQuadratic;
float intens = ls.intens >= 0 ? ls.intens : -ls.intens;
float attenEnd = ls.attenEnd;
// Decay type 0:None, 1:Linear, 2:Squared
if( ls.useAtten )
{
switch(((GenLight*)light)->GetDecayType())
{
case 0:
case 1:
attenConst = 1.f;
attenLinear = (intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / attenEnd;
attenQuadratic = 0;
break;
case 2:
attenConst = 1.f;
attenLinear = 0;
attenQuadratic = (intens * plSillyLightKonstants::GetFarPowerKonst() -1.f) / (attenEnd * attenEnd);
break;
case 3:
attenConst = intens;
attenLinear = 0.f;
attenQuadratic = 0.f;
liInfo->SetCutoffAttenuation( ( (GenLight *)light )->GetDecayRadius( timeVal ) );
break;
}
}
else
{
attenConst = 1.f;
attenLinear = 0.f;
attenQuadratic = 0.f;
}
liInfo->SetConstantAttenuation(attenConst);
liInfo->SetLinearAttenuation(attenLinear);
liInfo->SetQuadraticAttenuation(attenQuadratic);
}
hsBool plMaxNode::IGetRTLightAttenValues(IParamBlock2* ProperPB, hsScalar& attenConst, hsScalar& attenLinear, hsScalar& attenQuadratic, hsScalar &attenCutoff )
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
float intens = ProperPB->GetFloat(plRTLightBase::kIntensity, timeVal);
if( intens < 0 )
intens = -intens;
float attenEnd;
attenEnd = ProperPB->GetFloat(plRTLightBase::kAttenMaxFalloffEdit, timeVal);//ls.attenEnd;
// Decay Type New == 0 for Linear and 1 for Squared.... OLD and OBSOLETE:Decay type 0:None, 1:Linear, 2:Squared
// Oh, and now 2 = cutoff attenuation
if( ProperPB->GetInt(plRTLightBase::kUseAttenuationBool, timeVal))
{
switch(ProperPB->GetInt(plRTLightBase::kAttenTypeRadio, timeVal))//((GenLight*)light)->GetDecayType())
{
case 0:
attenConst = 1.f;
attenLinear = (intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / attenEnd;
if( attenLinear < 0 )
attenLinear = 0;
attenQuadratic = 0;
attenCutoff = attenEnd;
break;
case 1:
attenConst = 1.f;
attenLinear = 0;
attenQuadratic = (intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / (attenEnd * attenEnd);
if( attenQuadratic < 0 )
attenQuadratic = 0;
attenCutoff = attenEnd;
break;
case 2:
attenConst = intens;
attenLinear = 0.f;
attenQuadratic = 0.f;
attenCutoff = attenEnd;
break;
}
return true;
}
else
{
attenConst = 1.f;
attenLinear = 0.f;
attenQuadratic = 0.f;
attenCutoff = 0.f;
return true;
}
return false;
}
void plMaxNode::IGetRTLightAttenuation(plOmniLightInfo* liInfo, IParamBlock2* ProperPB)
{
hsScalar attenConst, attenLinear, attenQuadratic, attenCutoff;
if( IGetRTLightAttenValues(ProperPB, attenConst, attenLinear, attenQuadratic, attenCutoff) )
{
liInfo->SetConstantAttenuation(attenConst);
liInfo->SetLinearAttenuation(attenLinear);
liInfo->SetQuadraticAttenuation(attenQuadratic);
liInfo->SetCutoffAttenuation( attenCutoff );
}
}
void plMaxNode::IGetLightColors(plLightInfo* liInfo, LightObject* light, LightState& ls)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Point3 color = light->GetRGBColor(timeVal);
float intensity = light->GetIntensity(timeVal);
color *= intensity;
liInfo->SetAmbient(hsColorRGBA().Set(0,0,0,1.f));
if( ls.affectDiffuse )
liInfo->SetDiffuse(hsColorRGBA().Set(color.x, color.y, color.z, intensity));
else
liInfo->SetDiffuse(hsColorRGBA().Set(0,0,0,intensity));
if( ls.affectSpecular )
liInfo->SetSpecular(hsColorRGBA().Set(color.x, color.y, color.z, intensity));
else
liInfo->SetSpecular(hsColorRGBA().Set(0,0,0,intensity));
}
void plMaxNode::IGetRTLightColors(plLightInfo* liInfo, IParamBlock2* ProperPB)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Point3 color = ProperPB->GetPoint3(plRTLightBase::kLightColor, timeVal);//light->GetRGBColor(timeVal);
float intensity = ProperPB->GetFloat(plRTLightBase::kIntensity, timeVal); //light->GetIntensity(timeVal);
color *= intensity;
liInfo->SetAmbient(hsColorRGBA().Set(0,0,0,1.f));
if( ProperPB->GetInt( plRTLightBase::kAffectDiffuse, timeVal ) )
liInfo->SetDiffuse(hsColorRGBA().Set(color.x, color.y, color.z, intensity));
else
liInfo->SetDiffuse(hsColorRGBA().Set(0,0,0,intensity));
if( ProperPB->GetInt(plRTLightBase::kSpec, timeVal)) //ls.affectSpecular )
{
Color spec = ProperPB->GetColor(plRTLightBase::kSpecularColorSwatch);
liInfo->SetSpecular(hsColorRGBA().Set(spec.r, spec.g, spec.b, intensity));
}
else
liInfo->SetSpecular(hsColorRGBA().Set(0,0,0,intensity));
}
void plMaxNode::IGetCone(plSpotLightInfo* liInfo, LightObject* light, LightState& ls)
{
hsScalar inner = hsScalarDegToRad(ls.hotsize);
hsScalar outer = hsScalarDegToRad(ls.fallsize);
/// 4.26.2001 mcn - MAX gives us full angles, but we want to store half angles
liInfo->SetSpotInner( inner / 2.0f );
liInfo->SetSpotOuter( outer / 2.0f );
liInfo->SetFalloff(1.f);
}
void plMaxNode::IGetRTCone(plSpotLightInfo* liInfo, IParamBlock2* ProperPB)
{
//TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
hsScalar inner, outer;
inner = hsScalarDegToRad(ProperPB->GetFloat(plRTLightBase::kHotSpot, timeVal)); //ls.hotsize);
outer = hsScalarDegToRad(ProperPB->GetFloat(plRTLightBase::kFallOff, timeVal)); //ls.fallsize);
/// 4.26.2001 mcn - MAX gives us full angles, but we want to store half angles
liInfo->SetSpotInner( inner / 2.0f );
liInfo->SetSpotOuter( outer / 2.0f );
liInfo->SetFalloff(1.f);
}
plLightInfo* plMaxNode::IMakeSpot(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
LightObject *light = (LightObject*)obj->ConvertToType(timeVal, Class_ID(SPOT_LIGHT_CLASS_ID,0));
if( !light )
light = (LightObject*)obj->ConvertToType(timeVal, Class_ID(FSPOT_LIGHT_CLASS_ID,0));
LightState ls;
if (!(REF_SUCCEED == light->EvalLightState(timeVal, Interval(timeVal, timeVal), &ls)))
{
pErrMsg->Set(true, GetName(), "Trouble evaluating light").CheckAndAsk();
return nil;
}
plSpotLightInfo* spot = TRACKED_NEW plSpotLightInfo;
IGetLightColors(spot, light, ls);
IGetLightAttenuation(spot, light, ls);
IGetCone(spot, light, ls);
if( obj != light )
light->DeleteThis();
return spot;
}
plLightInfo* plMaxNode::IMakeOmni(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
LightObject *light = (LightObject*)obj->ConvertToType(timeVal,
Class_ID(OMNI_LIGHT_CLASS_ID,0));
LightState ls;
if (!(REF_SUCCEED == light->EvalLightState(timeVal, Interval(timeVal, timeVal), &ls)))
{
pErrMsg->Set(true, GetName(), "Trouble evaluating light").CheckAndAsk();
return nil;
}
plOmniLightInfo* omni = TRACKED_NEW plOmniLightInfo;
IGetLightAttenuation(omni, light, ls);
IGetLightColors(omni, light, ls);
if( obj != light )
light->DeleteThis();
return omni;
}
plLightInfo* plMaxNode::IMakeDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
LightObject *light = (LightObject*)obj->ConvertToType(timeVal, Class_ID(DIR_LIGHT_CLASS_ID,0));
if( !light )
light = (LightObject*)obj->ConvertToType(timeVal, Class_ID(TDIR_LIGHT_CLASS_ID,0));
LightState ls;
if (!(REF_SUCCEED == light->EvalLightState(timeVal, Interval(timeVal, timeVal), &ls)))
{
pErrMsg->Set(true, GetName(), "Trouble evaluating light").CheckAndAsk();
return nil;
}
plLightInfo* plasLight = nil;
if( light->GetProjMap() )
{
plLimitedDirLightInfo* ldl = TRACKED_NEW plLimitedDirLightInfo;
float sz = light->GetFallsize(timeVal, FOREVER);
float depth = 1000.f;
ldl->SetWidth(sz);
ldl->SetHeight(sz);
ldl->SetDepth(depth);
plasLight = ldl;
}
else
{
plDirectionalLightInfo* direct = TRACKED_NEW plDirectionalLightInfo;
plasLight = direct;
}
IGetLightColors(plasLight, light, ls);
if( obj != light )
light->DeleteThis();
return plasLight;
}
plLightInfo* plMaxNode::IMakeRTSpot(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
Object *ThisObj = ((INode*)this)->GetObjectRef();
IParamBlock2* ThisObjPB = ThisObj->GetParamBlockByID(plRTLightBase::kBlkSpotLight);
if(!obj->CanConvertToType(RTSPOT_LIGHT_CLASSID))
{
pErrMsg->Set(true, GetName(), "Trouble evaluating light, improper classID").CheckAndAsk();
return nil;
}
plSpotLightInfo* spot = TRACKED_NEW plSpotLightInfo;
if(!ThisObjPB->GetInt(plRTLightBase::kLightOn))
spot->SetProperty(plLightInfo::kDisable, true);
IGetRTLightColors(spot,ThisObjPB);
IGetRTLightAttenuation(spot,ThisObjPB);
IGetRTCone(spot, ThisObjPB);
//plSpotModifier* liMod = TRACKED_NEW plSpotModifier;
//GetRTLightColAnim(ThisObjPB, liMod);
//GetRTLightAttenAnim(ThisObjPB, liMod);
//GetRTConeAnim(ThisObjPB, liMod);
//IAttachRTLightModifier(liMod);
// if( obj != light )
// light->DeleteThis();
return spot;
}
plLightInfo* plMaxNode::IMakeRTOmni(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
Object *ThisObj = ((INode*)this)->GetObjectRef();
IParamBlock2* ThisObjPB = ThisObj->GetParamBlockByID(plRTLightBase::kBlkOmniLight);
plOmniLightInfo* omni = TRACKED_NEW plOmniLightInfo;
if(!ThisObjPB->GetInt(plRTLightBase::kLightOn))
omni->SetProperty(plLightInfo::kDisable, true);
IGetRTLightAttenuation(omni, ThisObjPB);
IGetRTLightColors(omni, ThisObjPB);
//plOmniModifier* liMod = TRACKED_NEW plOmniModifier;
//GetRTLightColAnim(ThisObjPB, liMod);
//GetRTLightAttenAnim(ThisObjPB, liMod);
//IAttachRTLightModifier(liMod);
// if( obj != light )
// light->DeleteThis();
return omni;
}
plLightInfo* plMaxNode::IMakeRTDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings)
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
Object *ThisObj = ((INode*)this)->GetObjectRef();
IParamBlock2* ThisObjPB = ThisObj->GetParamBlockByID(plRTLightBase::kBlkTSpotLight);
plDirectionalLightInfo* direct = TRACKED_NEW plDirectionalLightInfo;
if(!ThisObjPB->GetInt(plRTLightBase::kLightOn))
direct->SetProperty(plLightInfo::kDisable, true);
IGetRTLightColors(direct, ThisObjPB);
//plLightModifier* liMod = TRACKED_NEW plLightModifier;
//GetRTLightColAnim(ThisObjPB, liMod);
//IAttachRTLightModifier(liMod);
// if( obj != light )
// light->DeleteThis();
return direct;
}
//// IMakeRTProjDirectional //////////////////////////////////////////////////
// Conversion function for RT Projected Directional lights
plLightInfo *plMaxNode::IMakeRTProjDirectional( plErrorMsg *pErrMsg, plConvertSettings *settings )
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
Object *ThisObj = ((INode*)this)->GetObjectRef();
IParamBlock2 *mainPB = ThisObj->GetParamBlockByID( plRTLightBase::kBlkMain );
IParamBlock2 *projPB = ThisObj->GetParamBlockByID( plRTProjDirLight::kBlkProj );
plLimitedDirLightInfo *light = TRACKED_NEW plLimitedDirLightInfo;
light->SetWidth( projPB->GetFloat( plRTProjDirLight::kWidth ) );
light->SetHeight( projPB->GetFloat( plRTProjDirLight::kHeight ) );
light->SetDepth( projPB->GetFloat( plRTProjDirLight::kRange ) );
if( !mainPB->GetInt( plRTLightBase::kLightOn ) )
light->SetProperty( plLightInfo::kDisable, true );
IGetRTLightColors( light, mainPB );
//plLightModifier *liMod = TRACKED_NEW plLightModifier;
//GetRTLightColAnim( mainPB, liMod );
//IAttachRTLightModifier(liMod);
return light;
}
hsBool plMaxNode::IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg)
{
hsBool persp = false;
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
LightObject *light = (LightObject*)obj->ConvertToType(timeVal, RTSPOT_LIGHT_CLASSID);
if( light )
persp = true;
if( !light )
light = (LightObject*)obj->ConvertToType(timeVal, RTPDIR_LIGHT_CLASSID);
if( !light )
return false;
hsBool retVal = false;
Texmap* projMap = light->GetProjMap();
if( !projMap )
return false;
plConvert& convert = plConvert::Instance();
if( projMap->ClassID() != LAYER_TEX_CLASS_ID )
{
if( pErrMsg->Set(!(convert.fWarned & plConvert::kWarnedWrongProj), GetName(),
"Only Plasma Layers supported for projection").CheckAskOrCancel() )
{
convert.fWarned |= plConvert::kWarnedWrongProj;
}
pErrMsg->Set(false);
return false;
}
IParamBlock2 *pb = nil;
Class_ID cid = obj->ClassID();
// Get the paramblock
if (cid == RTSPOT_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkSpotLight);
else if (cid == RTOMNI_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkOmniLight);
else if (cid == RTDIR_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkTSpotLight);
else if (cid == RTPDIR_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTProjDirLight::kBlkProj);
// Have the layer converter process this layer directly
plLayerConverter::Instance().MuteWarnings();
plLayerInterface* proj = plLayerConverter::Instance().ConvertTexmap( projMap, this, 0, true, false );
plLayerConverter::Instance().UnmuteWarnings();
if( proj )
{
plLayer* projLay = plLayer::ConvertNoRef(proj->BottomOfStack());
if( projLay && projLay->GetTexture() )
{
if( persp )
projLay->SetMiscFlags(projLay->GetMiscFlags() | hsGMatState::kMiscPerspProjection);
else
projLay->SetMiscFlags(projLay->GetMiscFlags() | hsGMatState::kMiscOrthoProjection);
projLay->SetUVWSrc(projLay->GetUVWSrc() | plLayerInterface::kUVWPosition);
projLay->SetClampFlags(hsGMatState::kClampTexture);
projLay->SetZFlags(hsGMatState::kZNoZWrite);
switch( pb->GetInt(plRTLightBase::kProjTypeRadio) )
{
default:
case plRTLightBase::kIlluminate:
projLay->SetBlendFlags(hsGMatState::kBlendMult);
li->SetProperty(plLightInfo::kLPOverAll, false);
break;
case plRTLightBase::kAdd:
projLay->SetBlendFlags(hsGMatState::kBlendAdd);
li->SetProperty(plLightInfo::kLPOverAll, true);
break;
case plRTLightBase::kMult:
projLay->SetBlendFlags(hsGMatState::kBlendMult | hsGMatState::kBlendInvertColor | hsGMatState::kBlendInvertFinalColor);
li->SetProperty(plLightInfo::kLPOverAll, true);
break;
case plRTLightBase::kMADD:
projLay->SetBlendFlags(hsGMatState::kBlendMADD);
li->SetProperty(plLightInfo::kLPOverAll, true);
break;
}
hsgResMgr::ResMgr()->AddViaNotify(proj->GetKey(), TRACKED_NEW plGenRefMsg(li->GetKey(), plRefMsg::kOnCreate, 0, 0), plRefFlags::kActiveRef);
li->SetShadowCaster(false);
li->SetProperty(plLightInfo::kLPMovable, true);
retVal = true;
}
else
{
char buff[256];
if( projMap && projMap->GetName() && *projMap->GetName() )
sprintf(buff, "Can't find projected bitmap - %s", projMap->GetName());
else
sprintf(buff, "Can't find projected bitmap - <unknown>");
if( pErrMsg->Set(!(convert.fWarned & plConvert::kWarnedMissingProj), GetName(),
buff).CheckAskOrCancel() )
convert.fWarned |= plConvert::kWarnedMissingProj;
pErrMsg->Set(false);
retVal = false;
}
}
else
{
if( pErrMsg->Set(!(convert.fWarned & plConvert::kWarnedWrongProj), GetName(),
"Failure to convert projection map - check type.").CheckAskOrCancel() )
convert.fWarned |= plConvert::kWarnedWrongProj;
pErrMsg->Set(false);
retVal = false;
}
if( light != obj )
light->DeleteThis();
return retVal;
}
/*
hsBool plMaxNode::IAttachRTLightModifier(plLightModifier* liMod)
{
if( liMod->HasAnima() )
{
liMod->DefaultAnimation();
CreateModifierKey(liMod, "_ANIMA");
AddModifier(liMod);
}
else
{
delete liMod;
return false;
}
return true;
}
*/
bool plMaxNode::IsAnimatedLight()
{
Object *obj = GetObjectRef();
if (!obj)
return false;
const char* dbgNodeName = GetName();
Class_ID cid = obj->ClassID();
if (!(cid == RTSPOT_LIGHT_CLASSID ||
cid == RTOMNI_LIGHT_CLASSID ||
cid == RTDIR_LIGHT_CLASSID ||
cid == RTPDIR_LIGHT_CLASSID))
return false;
IParamBlock2 *pb = nil;
// Get the paramblock
if (cid == RTSPOT_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkSpotLight);
else if (cid == RTOMNI_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkOmniLight);
else if (cid == RTDIR_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkTSpotLight);
else if (cid == RTPDIR_LIGHT_CLASSID)
pb = obj->GetParamBlockByID(plRTLightBase::kBlkMain);
hsControlConverter& cc = hsControlConverter::Instance();
// Is the color animated?
Control *colorCtl = pb->GetController( ParamID( plRTLightBase::kLightColor ) );
if (colorCtl && cc.HasKeyTimes(colorCtl))
return true;
// Is the specularity animated?
Control *specCtl = pb->GetController( ParamID( plRTLightBase::kSpecularColorSwatch ) );
if (specCtl && cc.HasKeyTimes(specCtl))
return true;
// Is the attenuation animated? (Spot and Omni lights only)
if (cid == RTSPOT_LIGHT_CLASSID || cid == RTOMNI_LIGHT_CLASSID)
{
Control *falloffCtl = pb->GetController( ParamID( plRTLightBase::kAttenMaxFalloffEdit ) );
if (falloffCtl && cc.HasKeyTimes(falloffCtl))
return true;
}
// Is the cone animated? (Spot only)
if (cid == RTSPOT_LIGHT_CLASSID)
{
Control *innerCtl = pb->GetController( ParamID( plRTLightBase::kHotSpot ) );
if (innerCtl && cc.HasKeyTimes(innerCtl))
return true;
Control *outerCtl = pb->GetController( ParamID( plRTLightBase::kFallOff ) );
if (outerCtl && cc.HasKeyTimes(outerCtl))
return true;
}
return false;
}
void plMaxNode::GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim *anim)
{
if( ProperPB->GetInt(plRTLightBase::kUseAttenuationBool, TimeValue(0)) )
{
Control* falloffCtl = ProperPB->GetController(ParamID(plRTLightBase::kAttenMaxFalloffEdit));
if( falloffCtl )
{
plLeafController* subCtl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
subCtl = hsControlConverter::Instance().MakeScalarController(falloffCtl, this);
else
subCtl = hsControlConverter::Instance().MakeScalarController(falloffCtl, this,
anim->GetStart(), anim->GetEnd());
if( subCtl )
{
if( ProperPB->GetInt(plRTLightBase::kAttenTypeRadio, TimeValue(0)) == 2 )
{
// Animation of a cutoff attenuation, which only needs a scalar channel
plOmniCutoffApplicator *app = TRACKED_NEW plOmniCutoffApplicator();
app->SetChannelName(GetName());
plScalarControllerChannel *chan = TRACKED_NEW plScalarControllerChannel(subCtl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(subCtl->GetLength());
}
else
{
hsBool distSq = ProperPB->GetInt(plRTLightBase::kAttenTypeRadio, TimeValue(0));
int i;
for( i = 0; i < subCtl->GetNumKeys(); i++ )
{
hsScalarKey *key = subCtl->GetScalarKey(i);
if (key)
{
hsScalar attenEnd = key->fValue;
TimeValue tv = key->fFrame * MAX_TICKS_PER_FRAME;
hsScalar intens = ProperPB->GetFloat(plRTLightBase::kIntensity, tv);
hsScalar newVal = (intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / attenEnd;
if( distSq )
newVal /= attenEnd;
key->fValue = newVal;
}
hsBezScalarKey *bezKey = subCtl->GetBezScalarKey(i);
if (bezKey)
{
hsScalar attenEnd = bezKey->fValue;
TimeValue tv = bezKey->fFrame * MAX_TICKS_PER_FRAME;
hsScalar intens = ProperPB->GetFloat(plRTLightBase::kIntensity, tv);
hsScalar newVal = (intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / attenEnd;
if( distSq )
newVal /= attenEnd;
/// From the chain rule, fix our tangents.
bezKey->fInTan *= -(intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / (attenEnd*attenEnd);
if( distSq )
bezKey->fInTan *= 2.f / attenEnd;
bezKey->fOutTan *= -(intens * plSillyLightKonstants::GetFarPowerKonst() - 1.f) / (attenEnd*attenEnd);
if( distSq )
bezKey->fOutTan *= 2.f / attenEnd;
bezKey->fValue = newVal;
}
}
plAGApplicator *app;
if (distSq)
app = TRACKED_NEW plOmniSqApplicator;
else
app = TRACKED_NEW plOmniApplicator;
app->SetChannelName(GetName());
plScalarControllerChannel *chan = TRACKED_NEW plScalarControllerChannel(subCtl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(subCtl->GetLength());
hsScalar attenConst, attenLinear, attenQuadratic, attenCutoff;
IGetRTLightAttenValues(ProperPB, attenConst, attenLinear, attenQuadratic, attenCutoff);
plOmniLightInfo *info = plOmniLightInfo::ConvertNoRef(GetSceneObject()->GetGenericInterface(plOmniLightInfo::Index()));
if (info)
{
hsPoint3 initAtten(attenConst, attenLinear, attenQuadratic);
info->SetConstantAttenuation(attenConst);
info->SetLinearAttenuation(attenLinear);
info->SetQuadraticAttenuation(attenQuadratic);
}
else
hsAssert(false, "Failed to find light info");
}
}
}
}
}
void plMaxNode::IAdjustRTColorByIntensity(plController* ctl, IParamBlock2* ProperPB)
{
plLeafController* simp = plLeafController::ConvertNoRef(ctl);
plCompoundController* comp;
if( simp )
{
int i;
for( i = 0; i < simp->GetNumKeys(); i++ )
{
hsPoint3Key* key = simp->GetPoint3Key(i);
if (key)
{
TimeValue tv = key->fFrame * MAX_TICKS_PER_FRAME;
hsScalar intens = ProperPB->GetFloat(plRTLightBase::kIntensity, tv);
key->fValue *= intens;
}
hsBezPoint3Key* bezKey = simp->GetBezPoint3Key(i);
if (bezKey)
{
TimeValue tv = bezKey->fFrame * MAX_TICKS_PER_FRAME;
hsScalar intens = ProperPB->GetFloat(plRTLightBase::kIntensity, tv);
bezKey->fInTan *= intens;
bezKey->fOutTan *= intens;
bezKey->fValue *= intens;
}
}
}
else if( comp = plCompoundController::ConvertNoRef(ctl) )
{
int j;
for( j = 0; j < 3; j++ )
{
IAdjustRTColorByIntensity(comp->GetController(j), ProperPB);
}
}
}
void plMaxNode::GetRTLightColAnim(IParamBlock2* ProperPB, plAGAnim *anim)
{
Control* ambientCtl = nil; // Ambient not currently supported
Control* colorCtl = ProperPB->GetController(ParamID(plRTLightBase::kLightColor));
Control* specCtl = ProperPB->GetController(ParamID(plRTLightBase::kSpecularColorSwatch));
plPointControllerChannel *chan;
if( ambientCtl )
{
plController* ctl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
ctl = hsControlConverter::Instance().MakeColorController(ambientCtl, this);
else
ctl = hsControlConverter::Instance().MakeColorController(ambientCtl, this, anim->GetStart(), anim->GetEnd());
if( ctl )
{
plLightAmbientApplicator *app = TRACKED_NEW plLightAmbientApplicator();
app->SetChannelName(GetName());
chan = TRACKED_NEW plPointControllerChannel(ctl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(ctl->GetLength());
}
}
if( colorCtl )
{
plController* ctl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
ctl = hsControlConverter::Instance().MakeColorController(colorCtl, this);
else
ctl = hsControlConverter::Instance().MakeColorController(colorCtl, this, anim->GetStart(), anim->GetEnd());
if( ctl )
{
IAdjustRTColorByIntensity(ctl, ProperPB);
plLightDiffuseApplicator *app = TRACKED_NEW plLightDiffuseApplicator();
app->SetChannelName(GetName());
chan = TRACKED_NEW plPointControllerChannel(ctl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(ctl->GetLength());
}
}
if( specCtl )
{
plController* ctl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
ctl = hsControlConverter::Instance().MakeColorController(specCtl, this);
else
ctl = hsControlConverter::Instance().MakeColorController(specCtl, this, anim->GetStart(), anim->GetEnd());
if( ctl )
{
plLightSpecularApplicator *app = TRACKED_NEW plLightSpecularApplicator();
app->SetChannelName(GetName());
chan = TRACKED_NEW plPointControllerChannel(ctl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(ctl->GetLength());
}
}
}
void plMaxNode::GetRTConeAnim(IParamBlock2* ProperPB, plAGAnim *anim)
{
Control* innerCtl = ProperPB->GetController(ParamID(plRTLightBase::kHotSpot));
Control* outerCtl = ProperPB->GetController(ParamID(plRTLightBase::kFallOff));
plScalarControllerChannel *chan;
if( innerCtl )
{
plLeafController* ctl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
ctl = hsControlConverter::Instance().MakeScalarController(innerCtl, this);
else
ctl = hsControlConverter::Instance().MakeScalarController(innerCtl, this, anim->GetStart(), anim->GetEnd());
if( ctl )
{
plSpotInnerApplicator *app = TRACKED_NEW plSpotInnerApplicator();
app->SetChannelName(GetName());
chan = TRACKED_NEW plScalarControllerChannel(ctl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(ctl->GetLength());
}
}
if( outerCtl )
{
plController* ctl;
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
ctl = hsControlConverter::Instance().MakeScalarController(outerCtl, this);
else
ctl = hsControlConverter::Instance().MakeScalarController(outerCtl, this, anim->GetStart(), anim->GetEnd());
if( ctl )
{
plSpotOuterApplicator *app = TRACKED_NEW plSpotOuterApplicator();
app->SetChannelName(GetName());
chan = TRACKED_NEW plScalarControllerChannel(ctl);
app->SetChannel(chan);
anim->AddApplicator(app);
if (!strcmp(anim->GetName(), ENTIRE_ANIMATION_NAME))
anim->ExtendToLength(ctl->GetLength());
}
}
}
plXImposterComp* plMaxNode::GetXImposterComp()
{
int count = NumAttachedComponents();
int i;
for( i = 0; i < count; i++ )
{
// See if any are a x-imposter component.
plComponentBase *comp = GetAttachedComponent(i);
if( comp && (comp->ClassID() == XIMPOSTER_COMP_CID) )
{
plXImposterComp* ximp = (plXImposterComp*)comp;
return ximp;
}
}
return nil;
}
Point3 plMaxNode::GetFlexibility()
{
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// See if any are a flexibility component.
plComponentBase *comp = GetAttachedComponent(i);
if( comp && (comp->ClassID() == FLEXIBILITY_COMP_CID) )
{
plFlexibilityComponent* flex = (plFlexibilityComponent*)comp;
return flex->GetFlexibility();
}
}
return Point3(0.f, 0.f, 0.f);
}
plLightMapComponent* plMaxNode::GetLightMapComponent()
{
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// See if any are a flexibility component.
plComponentBase *comp = GetAttachedComponent(i);
if( comp && (comp->ClassID() == LIGHTMAP_COMP_CID) )
{
plLightMapComponent* lmap = (plLightMapComponent*)comp;
return lmap;
}
}
return nil;
}
plDrawableCriteria plMaxNode::GetDrawableCriteria(hsBool needBlending, hsBool needSorting)
{
plRenderLevel level = needBlending ? GetRenderLevel(needBlending) : plRenderLevel::OpaqueRenderLevel();
if( GetSortAsOpaque() )
level.Set(plRenderLevel::kOpaqueMajorLevel, level.Minor());
UInt32 crit = 0;
if( needBlending )
{
if( needSorting && !GetNoFaceSort() )
crit |= plDrawable::kCritSortFaces;
if( !GetNoSpanSort() )
crit |= plDrawable::kCritSortSpans;
}
if( GetItinerant() )
crit |= plDrawable::kCritCharacter;
plDrawableCriteria retVal(crit, level, GetLoadMask());
if( GetEnviron() )
retVal.fType |= plDrawable::kEnviron;
if( GetEnvironOnly() )
retVal.fType &= ~plDrawable::kNormal;
return retVal;
}
//// IGetSceneNodeSpans //////////////////////////////////////////////////////
// Gets the required drawableSpans from a sceneNode. Creates a new one
// if it can't find one.
plDrawableSpans *plMaxNode::IGetSceneNodeSpans( plSceneNode *node, hsBool needBlending, hsBool needSorting )
{
plDrawableSpans *spans;
char tmpName[ 512 ];
plLocation nodeLoc = GetLocation();
if( !needBlending )
needSorting = false;
plDrawableCriteria crit = GetDrawableCriteria(needBlending, needSorting);
spans = plDrawableSpans::ConvertNoRef( node->GetMatchingDrawable( crit ) );
if( spans != nil )
{
if( GetNoSpanReSort() )
{
spans->SetNativeProperty(plDrawable::kPropNoReSort, true);
}
return spans;
}
/// Couldn't find--create and return it
spans = TRACKED_NEW plDrawableSpans;
if( needBlending )
{
/// Blending (deferred) spans
spans->SetCriteria( crit );
sprintf( tmpName, "%s_%8.8x_%xBlendSpans", node->GetKeyName(), crit.fLevel.fLevel, crit.fCriteria);
}
else
{
/// Normal spans
spans->SetCriteria( crit );
sprintf( tmpName, "%s_%8.8x_%xSpans", node->GetKeyName(), crit.fLevel.fLevel, crit.fCriteria);
}
if (GetSwappableGeomTarget() != (UInt32)-1 || GetSwappableGeom()) // We intend to swap geometry with this node... flag the drawable as volatile
{
if( GetItinerant() )
spans->SetNativeProperty(plDrawable::kPropCharacter, true);
spans->SetNativeProperty( plDrawable::kPropVolatile, true );
}
// Add a key for the spans
plKey key = hsgResMgr::ResMgr()->NewKey( tmpName, spans, nodeLoc, GetLoadMask() );
spans->SetSceneNode(node->GetKey());
/// Created! Return it now...
if( GetNoSpanReSort() )
spans->SetNativeProperty(plDrawable::kPropNoReSort, true);
return spans;
}
hsBool plMaxNode::SetupPropertiesPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// For each one, call the requested function. If any of the attached components
// return false this function will return false.
plComponentBase *comp = GetAttachedComponent(i);
if (comp->IsExternal())
{
if (!((plComponentExt*)comp)->SetupProperties(this, &gComponentTools, pErrMsg))
ret = false;
}
else
{
if (!((plComponent*)comp)->SetupProperties(this, pErrMsg))
ret = false;
}
}
if( ret )
{
// Now loop through all the plPassMtlBase-derived materials that are applied to this node
Mtl *mtl = GetMtl();
if( mtl != nil && !GetParticleRelated() )
{
if( hsMaterialConverter::IsMultiMat( mtl ) || hsMaterialConverter::IsMultipassMat( mtl ) || hsMaterialConverter::IsCompositeMat( mtl ) )
{
int i;
for (i = 0; i < mtl->NumSubMtls(); i++)
{
plPassMtlBase *pass = plPassMtlBase::ConvertToPassMtl( mtl->GetSubMtl( i ) );
if( pass != nil )
{
if( !pass->SetupProperties( this, pErrMsg ) )
ret = false;
}
}
}
else
{
plPassMtlBase *pass = plPassMtlBase::ConvertToPassMtl( mtl );
if( pass != nil )
{
if( !pass->SetupProperties( this, pErrMsg ) )
ret = false;
}
}
}
}
if( ret )
{
plMaxNode* parent = (plMaxNode*)GetParentNode();
if( parent && IsLegalDecal(false) )
{
AddRenderDependency(parent);
SetNoSpanSort(true);
SetNoFaceSort(true);
SetNoDeferDraw(true);
}
}
return ret;
}
hsBool plMaxNode::FirstComponentPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
if (!CanConvert())
return ret;
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// For each one, call the requested function. If any of the attached components
// return false this function will return false.
plComponentBase *comp = GetAttachedComponent(i);
if (comp->IsExternal())
{
if (!((plComponentExt*)comp)->PreConvert(this, &gComponentTools, pErrMsg))
ret = false;
}
else
{
if (!((plComponent*)comp)->PreConvert(this, pErrMsg))
ret = false;
}
}
return ret;
}
hsBool plMaxNode::ConvertComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())
return ret;
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// For each one, call the requested function. If any of the attached components
// return false this function will return false.
plComponentBase *comp = GetAttachedComponent(i);
if (comp->IsExternal())
{
if (!((plComponentExt*)comp)->Convert(this, &gComponentTools, pErrMsg))
ret = false;
}
else
{
if (!((plComponent*)comp)->Convert(this, pErrMsg))
ret = false;
}
}
return ret;
}
hsBool plMaxNode::DeInitComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())
return ret;
UInt32 count = NumAttachedComponents();
// Go through all the components attached to this node
for (UInt32 i = 0; i < count; i++)
{
// For each one, call the requested function. If any of the attached components
// return false this function will return false.
plComponentBase *comp = GetAttachedComponent(i);
if (comp->IsExternal())
{
if (!((plComponentExt*)comp)->DeInit(this, &gComponentTools, pErrMsg))
ret = false;
}
else
{
if (!((plComponent*)comp)->DeInit(this, pErrMsg))
ret = false;
}
}
if( ret )
{
// Now loop through all the plPassMtlBase-derived materials that are applied to this node
// So we can call ConvertDeInit() on them
Mtl *mtl = GetMtl();
if( mtl != nil && !GetParticleRelated() )
{
if( hsMaterialConverter::IsMultiMat( mtl ) || hsMaterialConverter::IsMultipassMat( mtl ) || hsMaterialConverter::IsCompositeMat( mtl ) )
{
int i;
for (i = 0; i < mtl->NumSubMtls(); i++)
{
plPassMtlBase *pass = plPassMtlBase::ConvertToPassMtl( mtl->GetSubMtl( i ) );
if( pass != nil )
{
if( !pass->ConvertDeInit( this, pErrMsg ) )
ret = false;
}
}
}
else
{
plPassMtlBase *pass = plPassMtlBase::ConvertToPassMtl( mtl );
if( pass != nil )
{
if( !pass->ConvertDeInit( this, pErrMsg ) )
ret = false;
}
}
}
}
return ret;
}
hsBool plMaxNode::ClearData(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaAgeChunk);
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaDistChunk);
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaRoomChunk);
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaMaxNodeDataChunk);
// RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaSceneViewerChunk);
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaLightChunk);
return true;
}
// HASAGMOD
// Little special-purpose thing to see if a node has an animation graph modifier on it.
plAGModifier *plMaxNode::HasAGMod()
{
char *name = GetName();
if (CanConvert())
{
plSceneObject *SO = GetSceneObject();
int numMods = SO->GetNumModifiers();
for (int i = 0; i < numMods; i++)
{
const plModifier *mod = SO->GetModifier(i);
if(plAGModifier::ConvertNoRef(mod)) {
return (plAGModifier *)mod;
}
}
}
return nil;
}
plAGMasterMod *plMaxNode::GetAGMasterMod()
{
char *name = GetName();
if (CanConvert())
{
plSceneObject *SO = GetSceneObject();
int numMods = SO->GetNumModifiers();
for (int i = 0; i < numMods; i++)
{
const plModifier *mod = SO->GetModifier(i);
if(plAGMasterMod::ConvertNoRef(mod)) {
return (plAGMasterMod *)mod;
}
}
}
return nil;
}
// SETUPBONESALIASESRECUR
void plMaxNode::SetupBonesAliasesRecur(const char *rootName)
{
if(CanConvert()) {
if (!HasAGMod()) {
const char *nameToUse;
// parse UserPropsBuf for entire BoneName line
char localName[256];
TSTR propsBuf;
GetUserPropBuffer(propsBuf);
char* start=strstr(propsBuf, "BoneName=");
if (!start)
start=strstr(propsBuf, "bonename=");
const int len = hsStrlen("BoneName=");
if(start && UserPropExists("BoneName"))
{
start+=len;
int i=0;
while(*start != '\n' && *start != '\0' && *start)
{
hsAssert(i<256, "localName overflow");
localName[i++]=*start++;
}
localName[i]=0;
nameToUse = localName;
}
else
{
const char *nodeName = GetName();
// char str[256];
// sprintf(str, "Missing 'BoneName=foo' UserProp, on object %s, using node name", nodeName ? nodeName : "?");
// hsAssert(false, str);
nameToUse = nodeName;
}
/* char aliasName[256];
sprintf(aliasName, "%s_%s", rootName, nameToUse);
plUoid* uoid = hsgResMgr::ResMgr()->FindAlias(aliasName, plSceneObject::Index());
if( !uoid )
{
plAliasModifier* pAlMod = TRACKED_NEW plAliasModifier;
pAlMod->SetAlias(aliasName);
AddModifier(pAlMod);
}
*/
plAGModifier *mod = TRACKED_NEW plAGModifier(nameToUse);
AddModifier(mod, GetName());
}
}
int j = 0;
for( j = 0; j < NumberOfChildren(); j++ )
((plMaxNode*)GetChildNode(j))->SetupBonesAliasesRecur(rootName);
}
void plMaxNode::SetDISceneNodeSpans( plDrawInterface *di, hsBool needBlending )
{
// This poorly named function is currently only used by ParticleComponent.
// di->GetNumDrawables() will always be zero. In general, particles only
// need a blending drawable, which can always be index zero since it's the only
// one.
di->SetDrawable( di->GetNumDrawables(),
IGetSceneNodeSpans(plSceneNode::ConvertNoRef( GetRoomKey()->GetObjectPtr() ),
needBlending));
}
plMaxNode* plMaxNode::GetBonesRoot()
{
ISkin* skin = FindSkinModifier();
if( !skin )
return nil;
INode* bone = skin->GetBone(0);
if( !bone )
return nil;
while( !bone->GetParentNode()->IsRootNode() )
bone = bone->GetParentNode();
plMaxNode* boneRoot = (plMaxNode*)bone;
if( !(boneRoot && boneRoot->CanConvert()) )
return nil;
return boneRoot;
}
void plMaxNode::GetBonesRootsRecur(hsTArray<plMaxNode*>& nodes)
{
plMaxNode* bRoot = GetBonesRoot();
if( bRoot )
{
int idx = nodes.Find(bRoot);
if( idx == nodes.kMissingIndex )
nodes.Append(bRoot);
}
int i;
for( i = 0; i < NumberOfChildren(); i++ )
((plMaxNode*)GetChildNode(i))->GetBonesRootsRecur(nodes);
}
plSceneObject* plMaxNode::MakeCharacterHierarchy(plErrorMsg *pErrMsg)
{
plSceneObject* playerRoot = GetSceneObject();
if( pErrMsg->Set(playerRoot->GetDrawInterface() != nil, GetName(), "Non-helper as player root").CheckAndAsk() )
return nil;
const char *playerRootName = GetName();
hsTArray<plMaxNode*> bonesRoots;
int i;
for( i = 0; i < NumberOfChildren(); i++ )
((plMaxNode*)GetChildNode(i))->GetBonesRootsRecur(bonesRoots);
if( pErrMsg->Set(bonesRoots.GetCount() > 1, playerRootName, "Found multiple bones hierarchies").CheckAndAsk() )
return nil;
if( bonesRoots.GetCount() )
{
bonesRoots[0]->SetupBonesAliasesRecur(playerRootName);
plSceneObject* boneRootObj = bonesRoots[0]->GetSceneObject();
if( pErrMsg->Set(boneRootObj == nil, playerRootName, "No scene object for the bones root").CheckAndAsk() )
return nil;
if( boneRootObj != playerRoot )
hsMessageBox("This avatar's bone hierarchy does not have the avatar root node linked as a parent. "
"This may cause the avatar draw incorrectly.", playerRootName, hsMessageBoxNormal);
}
return playerRoot;
}
// Takes all bones found on this node (and any descendents) and sets up a single palette
void plMaxNode::SetupBoneHierarchyPalette(plMaxBoneMap *bones /* = nil */)
{
const char* dbgNodeName = GetName();
if( !CanConvert() )
return;
if (GetBoneMap())
return;
if (bones == nil)
{
bones = TRACKED_NEW plMaxBoneMap();
bones->fOwner = this;
}
if (UserPropExists("Bone"))
bones->AddBone(this);
int i;
for (i = 0; i < NumBones(); i++)
bones->AddBone(GetBone(i));
SetBoneMap(bones);
for (i = 0; i < NumberOfChildren(); i++)
((plMaxNode*)GetChildNode(i))->SetupBoneHierarchyPalette(bones);
// If we were the one to start this whole thing, then sort all the bones now that
// they've been added.
if (bones->fOwner == this)
bones->SortBones();
}
hsBool plMaxNode::IsLegalDecal(hsBool checkParent /* = true */)
{
Mtl *mtl = GetMtl();
if (mtl == nil || GetParticleRelated())
return false;
if (hsMaterialConverter::IsMultiMat(mtl))
{
int i;
for (i = 0; i < mtl->NumSubMtls(); i++)
{
if (!hsMaterialConverter::IsDecalMat(mtl->GetSubMtl(i)))
return false;
}
}
else if (!hsMaterialConverter::IsDecalMat(mtl))
return false;
return true;
}
int plMaxNode::NumUVWChannels()
{
hsBool deleteIt;
TriObject* triObj = GetTriObject(deleteIt);
if( triObj )
{
Mesh* mesh = &(triObj->mesh);
// note: There's been a bit of a change with UV accounting. There are two variables, numChannels
// and numBlendChannels. The first represents texture UV channels MAX gives us, the latter is
// the number of extra blending channels the current material uses to handle its effects.
// numMaps includes map #0, which is the vertex colors. So subtract 1 to get the # of uv maps...
int numChannels = mesh->getNumMaps() - 1;
if( numChannels > plGeometrySpan::kMaxNumUVChannels )
numChannels = plGeometrySpan::kMaxNumUVChannels;
/// Check the mapping channels. See, MAX likes to tell us we have mapping channels
/// but the actual channel pointer is nil. When MAX tries to render the scene, it says that the
/// object in question has no UV channel. So apparently we have to check numChannels *and*
/// that each mapChannel is non-nil...
int i;
for( i = 0; i < numChannels; i++ )
{
// i + 1 is exactly what IGenerateUVs uses, so I'm not questioning it...
if( mesh->mapFaces( i + 1 ) == nil )
{
numChannels = i;
break;
}
}
int numUsed = hsMaterialConverter::MaxUsedUVWSrc(this, GetMtl());
plLightMapComponent* lmc = GetLightMapComponent();
if( lmc )
{
if( (lmc->GetUVWSrc() < numChannels) && (lmc->GetUVWSrc() >= numUsed) )
numUsed = lmc->GetUVWSrc() + 1;
}
if( numChannels > numUsed )
numChannels = numUsed;
if( GetWaterDecEnv() )
numChannels = 3;
if( deleteIt )
triObj->DeleteThis();
return numChannels;
}
return 0;
}
//// IGet/SetCachedAlphaHackValue ////////////////////////////////////////////
// Pair of functions to handle accessing the TArray cache on plMaxNodeData.
// See AlphaHackLayersNeeded() for details.
int plMaxNode::IGetCachedAlphaHackValue( int iSubMtl )
{
plMaxNodeData *pDat = GetMaxNodeData();
if( pDat == nil )
return -1;
hsTArray<int> *cache = pDat->GetAlphaHackLayersCache();
if( cache == nil )
return -1;
iSubMtl++;
if( iSubMtl >= cache->GetCount() )
return -1;
return (*cache)[ iSubMtl ];
}
void plMaxNode::ISetCachedAlphaHackValue( int iSubMtl, int value )
{
plMaxNodeData *pDat = GetMaxNodeData();
if( pDat == nil )
return;
hsTArray<int> *cache = pDat->GetAlphaHackLayersCache();
if( cache == nil )
{
cache = TRACKED_NEW hsTArray<int>;
pDat->SetAlphaHackLayersCache( cache );
}
iSubMtl++;
if( iSubMtl >= cache->GetCount() )
{
int i = cache->GetCount();
cache->ExpandAndZero( iSubMtl + 1 );
for( ; i < cache->GetCount(); i++ )
(*cache)[ i ] = -1;
}
(*cache)[ iSubMtl ] = value;
}
//// AlphaHackLayersNeeded ///////////////////////////////////////////////////
// Updated 8.13.02 mcn - Turns out this function is actually very slow, and
// it also happens to be used a lot in testing instanced objects and whether
// they really can be instanced or not. Since the return value of this
// function will be constant after the SetupProperties() pass (and undefined
// before), we cache the value now after the first time we calculate it.
// Note: mf said that putting long comments in are good so long as most of
// them aren't obscenities, so I'm trying to keep the #*$&(*#$ obscenities
// to a minimum here.
int plMaxNode::AlphaHackLayersNeeded(int iSubMtl)
{
const char* dbgNodeName = GetName();
int cached = IGetCachedAlphaHackValue( iSubMtl );
if( cached != -1 )
return cached;
int numVtxOpacChanAvail = VtxAlphaNotAvailable() ? 0 : 1;
int numVtxOpacChanNeeded = hsMaterialConverter::NumVertexOpacityChannelsRequired(this, iSubMtl);
cached = numVtxOpacChanNeeded - numVtxOpacChanAvail;
ISetCachedAlphaHackValue( iSubMtl, cached );
return cached;
}
// Will our lighting pay attention to vertex alpha values?
hsBool plMaxNode::VtxAlphaNotAvailable()
{
if( NonVtxPreshaded() || GetParticleRelated())
return false;
return true;
}
hsBool plMaxNode::NonVtxPreshaded()
{
if( GetForceMatShade() )
return false;
if( GetAvatarSO() != nil ||
hsMaterialConverter::Instance().HasMaterialDiffuseOrOpacityAnimation(this) )
return false;
if( GetRunTimeLight() && !hsMaterialConverter::Instance().HasEmissiveLayer(this) )
return true;
return( GetLightMapComponent() != nil );
}
TriObject* plMaxNode::GetTriObject(hsBool& deleteIt)
{
// Get da object
Object *obj = EvalWorldState(TimeValue(0)).obj;
if( obj == nil )
return nil;
if( !obj->CanConvertToType(triObjectClassID) )
return nil;
// Convert to triMesh object
TriObject *meshObj = (TriObject *)obj->ConvertToType(TimeValue(0), triObjectClassID);
if( meshObj == nil )
return nil;
deleteIt = meshObj != obj;
return meshObj;
}
//// GetNextSoundIdx /////////////////////////////////////////////////////////
// Starting at 0, returns an incrementing index for each maxNode. Useful for
// assigning indices to sound objects attached to the node.
UInt32 plMaxNode::GetNextSoundIdx( void )
{
UInt32 idx = GetSoundIdxCounter();
SetSoundIdxCounter( idx + 1 );
return idx;
}
//// IsPhysical //////////////////////////////////////////////////////////////
// Fun temp hack function to tell if a maxNode is physical. Useful after
// preConvert (checks for a physical on the simInterface)
hsBool plMaxNode::IsPhysical( void )
{
if( GetSceneObject() && GetSceneObject()->GetSimulationInterface() &&
GetSceneObject()->GetSimulationInterface()->GetPhysical() )
return true;
return false;
}
plPhysicalProps *plMaxNode::GetPhysicalProps()
{
plMaxNodeData *pDat = GetMaxNodeData();
if (pDat)
return pDat->GetPhysicalProps();
return nil;
}
//// FindPageKey /////////////////////////////////////////////////////////////
// Little helper function. Calls FindKey() in the resManager using the location (page) of this node
plKey plMaxNode::FindPageKey( UInt16 classIdx, const char *name )
{
return hsgResMgr::ResMgr()->FindKey( plUoid( GetLocation(), classIdx, name ) );
}
char *plMaxNode::GetAgeName()
{
int i;
for (i = 0; i < NumAttachedComponents(); i++)
{
plComponentBase *comp = GetAttachedComponent(i);
if (comp->ClassID() == PAGEINFO_CID)
return ((plPageInfoComponent*)comp)->GetAgeName();
}
return nil;
}
// create a list of keys used by the run-time interface for things like
// determining cursor changes, what kind of object this is, etc.
// we're doing this here because multiple logic triggers can be attached to a
// single object and tracking down all their run-time counterpart objects (who might
// need a message sent to them) is a huge pain and very ugly. This will capture anything
// important in a single list.
hsBool plMaxNode::MakeIfaceReferences(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
hsBool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())
return ret;
UInt32 count = GetSceneObject()->GetNumModifiers();
hsTArray<plKey> keys;
// Go through all the modifiers attached to this node's scene object
// and grab keys for objects who we would need to send interface messages to
for (UInt32 i = 0; i < count; i++)
{
const plModifier* pMod = GetSceneObject()->GetModifier(i);
// right now all we care about are these, but I guarentee you we will
// care about more as the interface gets more complex
const plPickingDetector* pDet = plPickingDetector::ConvertNoRef(pMod);
const plLogicModifier* pLog = plLogicModifier::ConvertNoRef(pMod);
if( pDet )
{
for (int j = 0; j < pDet->GetNumReceivers(); j++)
keys.Append(pDet->GetReceiver(j));
}
else
if( pLog )
{
keys.Append(pLog->GetKey());
}
}
// if there is anything there, create an 'interface object modifier' which simply stores
// the list in a handy form
if (keys.Count())
{
plInterfaceInfoModifier* pMod = TRACKED_NEW plInterfaceInfoModifier;
plKey modifierKey = hsgResMgr::ResMgr()->NewKey(GetName(), pMod, GetLocation(), GetLoadMask());
hsgResMgr::ResMgr()->AddViaNotify(modifierKey, TRACKED_NEW plObjRefMsg(GetSceneObject()->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);
for(int i = 0; i < keys.Count(); i++)
pMod->AddRefdKey(keys[i]);
}
return ret;
}