OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-17 02:51:27 +00:00
Code Releases Activity

Obliterate hsBool

Browse Source
This commit is contained in:
Adam Johnson
2012-07-11 01:28:00 -04:00
parent 5f78b33db4
commit a709e17069
1041 changed files with 7889 additions and 8070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Sources/Tools/MaxMain/plAgeDescInterface.cpp
View File

@ -621,7 +621,7 @@ void plAgeDescInterface::IInvalidateCheckOutIndicator( void )
RedrawWindow( fhDlg, &r, nil, RDW_INVALIDATE | RDW_ERASE );
}
hsBool plAgeDescInterface::IMakeSureCheckedIn( void )
bool plAgeDescInterface::IMakeSureCheckedIn( void )
{
#ifdef MAXASS_AVAILABLE
int result;
@ -1120,7 +1120,7 @@ uint32_t plAgeDescInterface::IGetFreePageSeqSuffix( HWND pageCombo )
return searchSeq;
}
void plAgeDescInterface::ISaveCurAge( const char *path, hsBool checkSeqNum )
void plAgeDescInterface::ISaveCurAge( const char *path, bool checkSeqNum )
{
hsUNIXStream s;
if( !s.Open( path, "wt" ) )
@ -1200,7 +1200,7 @@ void plAgeDescInterface::ICheckSequenceNumber( plAgeDescription &aged )
}
}
void plAgeDescInterface::ILoadAge( const char *path, hsBool checkSeqNum )
void plAgeDescInterface::ILoadAge( const char *path, bool checkSeqNum )
{
ISetControlDefaults();
@ -1282,7 +1282,7 @@ void plAgeDescInterface::ILoadAge( const char *path, hsBool checkSeqNum )
}
}
uint32_t plAgeDescInterface::IGetNextFreeSequencePrefix( hsBool getReservedPrefix )
uint32_t plAgeDescInterface::IGetNextFreeSequencePrefix( bool getReservedPrefix )
{
int32_t searchSeq = getReservedPrefix ? -1 : 1;
hsTArray<char *> ageList;

8
Sources/Tools/MaxMain/plAgeDescInterface.h
View File

@ -109,8 +109,8 @@ protected:
// Save the settings for the last age and load the settings for the currently one
void IUpdateCurAge();
void ISaveCurAge( const char *path, hsBool checkSeqNum = false );
void ILoadAge( const char *path, hsBool checkSeqNum = false );
void ISaveCurAge( const char *path, bool checkSeqNum = false );
void ILoadAge( const char *path, bool checkSeqNum = false );
static bool IGetLocalAgePath(char *path);
@ -122,13 +122,13 @@ protected:
void INewPage();
uint32_t IGetNextFreeSequencePrefix( hsBool getReservedPrefix );
uint32_t IGetNextFreeSequencePrefix( bool getReservedPrefix );
uint32_t IGetFreePageSeqSuffix( HWND pageCombo );
void ICheckOutCurrentAge( void );
void ICheckInCurrentAge( void );
void IUndoCheckOutCurrentAge( void );
hsBool IMakeSureCheckedIn( void );
bool IMakeSureCheckedIn( void );
plAgeFile* IGetCurrentAge( void );

4
Sources/Tools/MaxMain/plCommonObjLib.cpp
View File

@ -75,7 +75,7 @@ class plCommonObjLibList
fRefCount++;
}
hsBool Remove( plCommonObjLib *lib )
bool Remove( plCommonObjLib *lib )
{
int idx = fLibs.Find( lib );
if( idx != fLibs.kMissingIndex )
@ -175,7 +175,7 @@ void plCommonObjLib::AddObject( hsKeyedObject *object )
// this function call, the key should no longer exist in the registry and be
// free to use elsewhere.
hsBool plCommonObjLib::RemoveObjectAndKey( plKey &key )
bool plCommonObjLib::RemoveObjectAndKey( plKey &key )
{
if (!key)
{

4
Sources/Tools/MaxMain/plCommonObjLib.h
View File

@ -89,12 +89,12 @@ class plCommonObjLib
/// Base utility functions
void AddObject( hsKeyedObject *object );
hsBool RemoveObjectAndKey( plKey &key );
bool RemoveObjectAndKey( plKey &key );
hsKeyedObject *FindObject( const plString &name, uint16_t classType = (uint16_t)-1 );
void ClearObjectList( void );
/// THIS IS YOUR VIRTUAL HERE. Override this to define which objects you collect
virtual hsBool IsInteresting( const plKey &objectKey ) { return false; }
virtual bool IsInteresting( const plKey &objectKey ) { return false; }
/// Static functions for use only by the export resManager

2
Sources/Tools/MaxMain/plMaxMeshExtractor.cpp
View File

@ -206,7 +206,7 @@ bool plMaxMeshExtractor::Extract(plMaxMeshExtractor::NeutralMesh& mesh, plMaxNod
//
// Create the arrays of verts and faces
//
hsBool isDummy = (node->EvalWorldState(0).obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0));
bool isDummy = (node->EvalWorldState(0).obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0));
if (isDummy)
{
hsMatrix44 w2l = masterNode->GetWorldToLocal44();

152
Sources/Tools/MaxMain/plMaxNode.cpp
View File

@ -144,7 +144,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
extern UserPropMgr gUserPropMgr;
hsBool ThreePlaneIntersect(const hsVector3& norm0, const hsPoint3& point0,
bool ThreePlaneIntersect(const hsVector3& norm0, const hsPoint3& point0,
const hsVector3& norm1, const hsPoint3& point1,
const hsVector3& norm2, const hsPoint3& point2, hsPoint3& loc);
@ -235,7 +235,7 @@ void plMaxBoneMap::SortBones()
int i,j;
for (i = 0; i < fNumBones; i++)
{
hsBool swap = false;
bool swap = false;
for (j = i + 1; j < fNumBones; j++)
{
if (strcmp(tempBones[i]->GetName(), tempBones[j]->GetName()) > 0)
@ -267,7 +267,7 @@ plKey plMaxNode::AddModifier(plModifier *pMod, const plString& name)
return modKey;
}
hsBool plMaxNode::DoRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConvertSettings *settings,plExportProgressBar*bar)
bool plMaxNode::DoRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConvertSettings *settings,plExportProgressBar*bar)
{
#ifdef HS_DEBUGGING
const char *tmpName = GetName();
@ -297,7 +297,7 @@ hsBool plMaxNode::DoRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConver
// 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)
bool plMaxNode::DoAllRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plConvertSettings *settings,plExportProgressBar*bar)
{
#ifdef HS_DEBUGGING
const char *tmpName = GetName();
@ -321,7 +321,7 @@ hsBool plMaxNode::DoAllRecur(PMaxNodeFunc pDoFunction,plErrorMsg *pErrMsg, plCon
return true;
}
hsBool plMaxNode::ConvertValidate(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::ConvertValidate(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
TimeValue t = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState( t ).obj;
@ -330,7 +330,7 @@ hsBool plMaxNode::ConvertValidate(plErrorMsg *pErrMsg, plConvertSettings *settin
// 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);
bool canConvert = CanConvert(true);
plMaxNodeData thisNodeData; // Extra data stored for each node
@ -403,7 +403,7 @@ hsBool plMaxNode::ConvertValidate(plErrorMsg *pErrMsg, plConvertSettings *settin
return canConvert;
}
hsBool plMaxNode::ClearMaxNodeData(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool 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.
@ -511,7 +511,7 @@ void plMaxNode::CheckSynchOptions(plSynchedObject* so)
}
}
hsBool plMaxNode::MakeSceneObject(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeSceneObject(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgName = GetName();
if (!CanConvert())
@ -551,7 +551,7 @@ hsBool plMaxNode::MakeSceneObject(plErrorMsg *pErrMsg, plConvertSettings *settin
return true;
}
hsBool plMaxNode::PrepareSkin(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::PrepareSkin(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !IFindBones(pErrMsg, settings) )
return false;
@ -569,7 +569,7 @@ hsBool plMaxNode::PrepareSkin(plErrorMsg *pErrMsg, plConvertSettings *settings)
return true;
}
hsBool plMaxNode::IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !CanConvert() )
return false;
@ -621,7 +621,7 @@ hsBool plMaxNode::IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings)
#include "plPhysX/plSimulationMgr.h"
#include "hsSTLStream.h"
hsBool plMaxNode::MakePhysical(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakePhysical(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
@ -872,14 +872,14 @@ hsBool plMaxNode::MakePhysical(plErrorMsg *pErrMsg, plConvertSettings *settings)
return true;
}
hsBool plMaxNode::MakeController(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeController(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
hsBool forceLocal = hsControlConverter::Instance().ForceLocal(this);
bool 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
bool 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);
@ -891,16 +891,16 @@ hsBool plMaxNode::MakeController(plErrorMsg *pErrMsg, plConvertSettings *setting
return true;
}
hsBool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
if (!CanConvert())
return false;
plCoordinateInterface* ci = nil;
hsBool forceLocal = GetForceLocal();
bool forceLocal = GetForceLocal();
hsBool needCI = (!GetParentNode()->IsRootNode())
bool needCI = (!GetParentNode()->IsRootNode())
|| NumberOfChildren()
|| forceLocal;
// If we have a transform, set up a coordinateinterface
@ -923,7 +923,7 @@ hsBool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings
plKey pCiKey = hsgResMgr::ResMgr()->NewKey(pName, ci,nodeLoc, GetLoadMask());
ci->SetLocalToParent(loc2Par, par2Loc);
hsBool usesPhysics = GetPhysicalProps()->IsUsed();
bool usesPhysics = GetPhysicalProps()->IsUsed();
ci->SetProperty(plCoordinateInterface::kCanEverDelayTransform, !usesPhysics);
ci->SetProperty(plCoordinateInterface::kDelayedTransformEval, !usesPhysics);
@ -932,15 +932,15 @@ hsBool plMaxNode::MakeCoordinateInterface(plErrorMsg *pErrMsg, plConvertSettings
return true;
}
hsBool plMaxNode::MakeModifiers(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeModifiers(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
hsBool forceLocal = GetForceLocal();
bool forceLocal = GetForceLocal();
const char *dbgNodeName = GetName();
hsBool addMods = (!GetParentNode()->IsRootNode())
bool addMods = (!GetParentNode()->IsRootNode())
|| forceLocal;
if (addMods)
@ -997,7 +997,7 @@ hsBool plMaxNode::MakeModifiers(plErrorMsg *pErrMsg, plConvertSettings *settings
}
hsBool plMaxNode::MakeParentOrRoomConnection(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeParentOrRoomConnection(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
return false;
@ -1020,7 +1020,7 @@ hsBool plMaxNode::MakeParentOrRoomConnection(plErrorMsg *pErrMsg, plConvertSetti
return true;
}
void plMaxNode::IWipeBranchDrawable(hsBool b)
void plMaxNode::IWipeBranchDrawable(bool b)
{
SetDrawable(b);
for (int i = 0; i < NumberOfChildren(); i++)
@ -1037,7 +1037,7 @@ void plMaxNode::IWipeBranchDrawable(hsBool b)
// 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 )
bool plMaxNode::CanMakeMesh( Object *obj, plErrorMsg *pErrMsg, plConvertSettings *settings )
{
if( obj == nil )
return false;
@ -1071,7 +1071,7 @@ void ITestAdjacencyRecur(const hsTArray<int>* vertList, int iVert, hsBitVector&
}
}
hsBool ITestAdjacency(const hsTArray<int>* vertList, int numVerts)
bool ITestAdjacency(const hsTArray<int>* vertList, int numVerts)
{
hsBitVector adjVerts;
ITestAdjacencyRecur(vertList, 0, adjVerts);
@ -1097,8 +1097,8 @@ int IsGeoSpanConvexExhaust(const plGeometrySpan* span)
uint8_t* vertData = span->fVertexData;
int numVerts = span->fNumVerts;
hsBool someIn = false;
hsBool someOut = false;
bool someIn = false;
bool someOut = false;
int i;
for( i = 0; i < numFaces; i++ )
@ -1218,8 +1218,8 @@ int IsGeoSpanConvex(plMaxNode* node, const plGeometrySpan* span)
idx += 3;
}
hsBool someIn = false;
hsBool someOut = false;
bool someIn = false;
bool someOut = false;
int i;
for( i = 0; i < numVerts; i++ )
{
@ -1270,13 +1270,13 @@ plDrawInterface* plMaxNode::GetDrawInterface()
return di;
}
hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
hsTArray<plGeometrySpan *> spanArray;
plDrawInterface *newDI = nil;
hsBool gotMade = false;
hsBool haveAddedToSceneNode = false;
bool gotMade = false;
bool haveAddedToSceneNode = false;
hsGMesh *myMesh = nil;
uint32_t i, triMeshIndex = (uint32_t)-1;
const char *dbgNodeName = GetName();
@ -1340,7 +1340,7 @@ hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
// 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();
bool movable = IsMovable();
if( !gotMade )
{
@ -1372,8 +1372,8 @@ hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
spanArray[ i ]->fProps |= shadeFlags;
}
hsBool DecalMat = false;
hsBool NonDecalMat = false;
bool DecalMat = false;
bool NonDecalMat = false;
for (i = 0; i < spanArray.GetCount(); i++)
{
@ -1397,10 +1397,10 @@ hsBool plMaxNode::MakeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
return false;
}
hsBool isDecal = IsLegalDecal(false); // Don't complain about the parent
bool isDecal = IsLegalDecal(false); // Don't complain about the parent
/// Get some stuff
hsBool forceLocal = GetForceLocal();
bool forceLocal = GetForceLocal();
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
@ -1536,7 +1536,7 @@ void plMaxNode::IAssignSpansToDrawables( hsTArray<plGeometrySpan *> &spanArra
{
if( spanArray[ i ]->fProps & plGeometrySpan::kRequiresBlending )
{
hsBool needFaceSort = !GetNoFaceSort() && !IsGeoSpanConvex(this, spanArray[i]);
bool needFaceSort = !GetNoFaceSort() && !IsGeoSpanConvex(this, spanArray[i]);
if( needFaceSort )
{
sCount++;
@ -1789,7 +1789,7 @@ void plMaxNode::ISetupBones(plDrawableSpans *drawable, hsTArray<plGeometrySpa
// 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,
bool plMaxNode::IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan *> &spanArray,
plErrorMsg *pErrMsg, plConvertSettings *settings )
{
uint8_t iDraw;
@ -1804,7 +1804,7 @@ hsBool plMaxNode::IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan
if( !di )
return false;
hsBool setVisDists = false;
bool setVisDists = false;
float minDist, maxDist;
if( hsMaterialConverter::HasVisDists(this, 0, minDist, maxDist) )
{
@ -1902,7 +1902,7 @@ hsBool plMaxNode::IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan
// For the given object, builds a list of all the iNodes that have that
// object as their object. Returns the total node count
uint32_t plMaxNode::IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, hsBool beMoreAccurate )
uint32_t plMaxNode::IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, bool beMoreAccurate )
{
Object *thisObj = EvalWorldState( t ).obj;
DependentIterator di( obj );
@ -1952,7 +1952,7 @@ uint32_t plMaxNode::IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMa
// 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 )
bool plMaxNode::IMaterialsMatch( plMaxNode *otherNode, bool beMoreAccurate )
{
Mtl *mtl = GetMtl(), *otherMtl = otherNode->GetMtl();
if( mtl != otherMtl )
@ -1986,7 +1986,7 @@ hsBool plMaxNode::IMaterialsMatch( plMaxNode *otherNode, hsBool beMoreAccurate
return true;
}
hsBool plMaxNode::ShadeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::ShadeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
const char* dbgNodeName = GetName();
@ -2043,13 +2043,13 @@ hsBool plMaxNode::ShadeMesh(plErrorMsg *pErrMsg, plConvertSettings *settings)
return true;
}
hsBool plMaxNode::MakeOccluder(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeOccluder(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if( !UserPropExists("Occluder") )
return true;
hsBool twoSided = UserPropExists("OccTwoSided");
hsBool isHole = UserPropExists("OccHole");
bool twoSided = UserPropExists("OccTwoSided");
bool isHole = UserPropExists("OccHole");
return ConvertToOccluder(pErrMsg, twoSided, isHole);
}
@ -2077,7 +2077,7 @@ static void IRemoveCollinearPoints(hsTArray<Point3>& facePts)
}
}
hsBool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, hsBool twoSided, hsBool isHole)
bool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, bool twoSided, bool isHole)
{
if( !CanConvert() )
return false;
@ -2085,7 +2085,7 @@ hsBool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, hsBool twoSided, hsBool
/// Get some stuff
plLocation nodeLoc = GetLocation();
hsBool moving = IsMovable();
bool moving = IsMovable();
if( moving )
moving++;
@ -2272,7 +2272,7 @@ hsBool plMaxNode::ConvertToOccluder(plErrorMsg* pErrMsg, hsBool twoSided, hsBool
return true;
}
hsBool plMaxNode::MakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::MakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
if (!CanConvert())
@ -2283,7 +2283,7 @@ hsBool plMaxNode::MakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings)
/// Get some stuff
plLocation nodeLoc = GetLocation();
hsBool forceLocal = GetForceLocal();
bool forceLocal = GetForceLocal();
hsMatrix44 l2w = GetLocalToWorld44();
hsMatrix44 w2l = GetWorldToLocal44();
@ -2398,7 +2398,7 @@ void plMaxNode::IGetLightAttenuation(plOmniLightInfo* liInfo, LightObject* light
}
hsBool plMaxNode::IGetRTLightAttenValues(IParamBlock2* ProperPB, float& attenConst, float& attenLinear, float& attenQuadratic, float &attenCutoff )
bool plMaxNode::IGetRTLightAttenValues(IParamBlock2* ProperPB, float& attenConst, float& attenLinear, float& attenQuadratic, float &attenCutoff )
{
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
@ -2774,9 +2774,9 @@ plLightInfo *plMaxNode::IMakeRTProjDirectional( plErrorMsg *pErrMsg, plConvertSe
return light;
}
hsBool plMaxNode::IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg)
bool plMaxNode::IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg)
{
hsBool persp = false;
bool persp = false;
TimeValue timeVal = hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(timeVal).obj;
LightObject *light = (LightObject*)obj->ConvertToType(timeVal, RTSPOT_LIGHT_CLASSID);
@ -2790,7 +2790,7 @@ hsBool plMaxNode::IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg)
if( !light )
return false;
hsBool retVal = false;
bool retVal = false;
Texmap* projMap = light->GetProjMap();
if( !projMap )
return false;
@ -2897,7 +2897,7 @@ hsBool plMaxNode::IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg)
return retVal;
}
/*
hsBool plMaxNode::IAttachRTLightModifier(plLightModifier* liMod)
bool plMaxNode::IAttachRTLightModifier(plLightModifier* liMod)
{
if( liMod->HasAnima() )
{
@ -3006,7 +3006,7 @@ void plMaxNode::GetRTLightAttenAnim(IParamBlock2* ProperPB, plAGAnim *anim)
}
else
{
hsBool distSq = ProperPB->GetInt(plRTLightBase::kAttenTypeRadio, TimeValue(0));
bool distSq = ProperPB->GetInt(plRTLightBase::kAttenTypeRadio, TimeValue(0));
int i;
for( i = 0; i < subCtl->GetNumKeys(); i++ )
@ -3280,7 +3280,7 @@ plLightMapComponent* plMaxNode::GetLightMapComponent()
return nil;
}
plDrawableCriteria plMaxNode::GetDrawableCriteria(hsBool needBlending, hsBool needSorting)
plDrawableCriteria plMaxNode::GetDrawableCriteria(bool needBlending, bool needSorting)
{
plRenderLevel level = needBlending ? GetRenderLevel(needBlending) : plRenderLevel::OpaqueRenderLevel();
@ -3313,7 +3313,7 @@ plDrawableCriteria plMaxNode::GetDrawableCriteria(hsBool needBlending, hsBool ne
// 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 *plMaxNode::IGetSceneNodeSpans( plSceneNode *node, bool needBlending, bool needSorting )
{
plDrawableSpans *spans;
@ -3372,14 +3372,14 @@ plDrawableSpans *plMaxNode::IGetSceneNodeSpans( plSceneNode *node, hsBool needBl
return spans;
}
hsBool plMaxNode::SetupPropertiesPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::SetupPropertiesPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
bool ret = true;
uint32_t count = NumAttachedComponents();
@ -3447,14 +3447,14 @@ hsBool plMaxNode::SetupPropertiesPass(plErrorMsg *pErrMsg, plConvertSettings *se
return ret;
}
hsBool plMaxNode::FirstComponentPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::FirstComponentPass(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
bool ret = true;
if (!CanConvert())
return ret;
@ -3482,14 +3482,14 @@ hsBool plMaxNode::FirstComponentPass(plErrorMsg *pErrMsg, plConvertSettings *set
return ret;
}
hsBool plMaxNode::ConvertComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::ConvertComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
bool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())
@ -3519,14 +3519,14 @@ hsBool plMaxNode::ConvertComponents(plErrorMsg *pErrMsg, plConvertSettings *sett
return ret;
}
hsBool plMaxNode::DeInitComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::DeInitComponents(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
// TEMP
if (IsComponent())
return false;
// End TEMP
hsBool ret = true;
bool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())
@ -3588,7 +3588,7 @@ hsBool plMaxNode::DeInitComponents(plErrorMsg *pErrMsg, plConvertSettings *setti
return ret;
}
hsBool plMaxNode::ClearData(plErrorMsg *pErrMsg, plConvertSettings *settings)
bool plMaxNode::ClearData(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaAgeChunk);
RemoveAppDataChunk(PLASMA_MAX_CLASSID, GUP_CLASS_ID, kPlasmaDistChunk);
@ -3704,7 +3704,7 @@ void plMaxNode::SetupBonesAliasesRecur(const char *rootName)
((plMaxNode*)GetChildNode(j))->SetupBonesAliasesRecur(rootName);
}
void plMaxNode::SetDISceneNodeSpans( plDrawInterface *di, hsBool needBlending )
void plMaxNode::SetDISceneNodeSpans( plDrawInterface *di, bool needBlending )
{
// This poorly named function is currently only used by ParticleComponent.
// di->GetNumDrawables() will always be zero. In general, particles only
@ -3819,7 +3819,7 @@ void plMaxNode::SetupBoneHierarchyPalette(plMaxBoneMap *bones /* = nil */)
bones->SortBones();
}
hsBool plMaxNode::IsLegalDecal(hsBool checkParent /* = true */)
bool plMaxNode::IsLegalDecal(bool checkParent /* = true */)
{
Mtl *mtl = GetMtl();
if (mtl == nil || GetParticleRelated())
@ -3841,7 +3841,7 @@ hsBool plMaxNode::IsLegalDecal(hsBool checkParent /* = true */)
int plMaxNode::NumUVWChannels()
{
hsBool deleteIt;
bool deleteIt;
TriObject* triObj = GetTriObject(deleteIt);
if( triObj )
@ -3968,7 +3968,7 @@ int plMaxNode::AlphaHackLayersNeeded(int iSubMtl)
}
// Will our lighting pay attention to vertex alpha values?
hsBool plMaxNode::VtxAlphaNotAvailable()
bool plMaxNode::VtxAlphaNotAvailable()
{
if( NonVtxPreshaded() || GetParticleRelated())
return false;
@ -3976,7 +3976,7 @@ hsBool plMaxNode::VtxAlphaNotAvailable()
return true;
}
hsBool plMaxNode::NonVtxPreshaded()
bool plMaxNode::NonVtxPreshaded()
{
if( GetForceMatShade() )
return false;
@ -3991,7 +3991,7 @@ hsBool plMaxNode::NonVtxPreshaded()
return( GetLightMapComponent() != nil );
}
TriObject* plMaxNode::GetTriObject(hsBool& deleteIt)
TriObject* plMaxNode::GetTriObject(bool& deleteIt)
{
// Get da object
Object *obj = EvalWorldState(TimeValue(0)).obj;
@ -4026,7 +4026,7 @@ uint32_t plMaxNode::GetNextSoundIdx( void )
// 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 )
bool plMaxNode::IsPhysical( void )
{
if( GetSceneObject() && GetSceneObject()->GetSimulationInterface() &&
GetSceneObject()->GetSimulationInterface()->GetPhysical() )
@ -4072,9 +4072,9 @@ const char *plMaxNode::GetAgeName()
// 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)
bool plMaxNode::MakeIfaceReferences(plErrorMsg *pErrMsg, plConvertSettings *settings)
{
hsBool ret = true;
bool ret = true;
char *dbgNodeName = GetName();
if (!CanConvert())

82
Sources/Tools/MaxMain/plMaxNode.h
View File

@ -81,7 +81,7 @@ class plPageInfoComponent;
class plMaxBoneMap;
class plSynchedObject;
typedef hsBool (plMaxNode:: *PMaxNodeFunc) (plErrorMsg *, plConvertSettings *); // Function pointer to a plMaxNode member funtion
typedef bool (plMaxNode:: *PMaxNodeFunc) (plErrorMsg *, plConvertSettings *); // Function pointer to a plMaxNode member funtion
class plMaxNodeTab : public Tab<plMaxNode*>
{
@ -102,47 +102,47 @@ class plMaxNodeTab : public Tab<plMaxNode*>
class plMaxNode : public plMaxNodeBase
{
public:
hsBool DoRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
hsBool DoAllRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
bool DoRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
bool DoAllRecur(PMaxNodeFunc p,plErrorMsg *, plConvertSettings *, plExportProgressBar*);
// DoRecur takes one of the following functions
hsBool ConvertValidate (plErrorMsg *, plConvertSettings *);
hsBool SetupPropertiesPass (plErrorMsg *, plConvertSettings *);
hsBool MakeSceneObject (plErrorMsg *, plConvertSettings *);
hsBool PrepareSkin (plErrorMsg *, plConvertSettings *);
hsBool MakePhysical (plErrorMsg *, plConvertSettings *);
hsBool FirstComponentPass (plErrorMsg *, plConvertSettings *);
hsBool MakeController (plErrorMsg *, plConvertSettings *);
hsBool MakeCoordinateInterface (plErrorMsg *, plConvertSettings *);
hsBool MakeModifiers (plErrorMsg *, plConvertSettings *);
hsBool MakeParentOrRoomConnection (plErrorMsg *, plConvertSettings *);
hsBool MakeMesh (plErrorMsg *, plConvertSettings *);
hsBool MakeLight (plErrorMsg *, plConvertSettings *);
hsBool MakeOccluder (plErrorMsg *, plConvertSettings *);
hsBool ConvertComponents (plErrorMsg *, plConvertSettings *);
hsBool ClearData (plErrorMsg *, plConvertSettings *);
hsBool ShadeMesh (plErrorMsg *, plConvertSettings *);
hsBool MakeIfaceReferences (plErrorMsg *, plConvertSettings *);
hsBool ClearMaxNodeData (plErrorMsg *, plConvertSettings *);
hsBool DeInitComponents (plErrorMsg *, plConvertSettings *);
bool ConvertValidate (plErrorMsg *, plConvertSettings *);
bool SetupPropertiesPass (plErrorMsg *, plConvertSettings *);
bool MakeSceneObject (plErrorMsg *, plConvertSettings *);
bool PrepareSkin (plErrorMsg *, plConvertSettings *);
bool MakePhysical (plErrorMsg *, plConvertSettings *);
bool FirstComponentPass (plErrorMsg *, plConvertSettings *);
bool MakeController (plErrorMsg *, plConvertSettings *);
bool MakeCoordinateInterface (plErrorMsg *, plConvertSettings *);
bool MakeModifiers (plErrorMsg *, plConvertSettings *);
bool MakeParentOrRoomConnection (plErrorMsg *, plConvertSettings *);
bool MakeMesh (plErrorMsg *, plConvertSettings *);
bool MakeLight (plErrorMsg *, plConvertSettings *);
bool MakeOccluder (plErrorMsg *, plConvertSettings *);
bool ConvertComponents (plErrorMsg *, plConvertSettings *);
bool ClearData (plErrorMsg *, plConvertSettings *);
bool ShadeMesh (plErrorMsg *, plConvertSettings *);
bool MakeIfaceReferences (plErrorMsg *, plConvertSettings *);
bool ClearMaxNodeData (plErrorMsg *, plConvertSettings *);
bool DeInitComponents (plErrorMsg *, plConvertSettings *);
// Does specified function for all components attached to this node
enum { kSetupProperties, kPreConvert, kConvert };
hsBool DoComponents(int convertType, plErrorMsg *, plConvertSettings *);
bool DoComponents(int convertType, plErrorMsg *, plConvertSettings *);
plKey AddModifier(plModifier *pMod, const plString& name);
hsBool ConvertToOccluder (plErrorMsg* pErrMsg, hsBool twoSided, hsBool isHole);
bool ConvertToOccluder (plErrorMsg* pErrMsg, bool twoSided, bool isHole);
plDrawableCriteria GetDrawableCriteria(hsBool needBlending, hsBool needSorting);
plDrawableCriteria GetDrawableCriteria(bool needBlending, bool needSorting);
Point3 GetFlexibility(); // returns Point3(flexibility, interRand, intraRand).
plXImposterComp* GetXImposterComp();
int AlphaHackLayersNeeded(int iSubMtl);
int NumUVWChannels();
hsBool VtxAlphaNotAvailable();
hsBool NonVtxPreshaded();
TriObject* GetTriObject(hsBool& deleteIt);
bool VtxAlphaNotAvailable();
bool NonVtxPreshaded();
TriObject* GetTriObject(bool& deleteIt);
plAGModifier* HasAGMod();
plAGMasterMod* GetAGMasterMod();
@ -152,9 +152,9 @@ public:
void SetupBonesAliasesRecur(const char *rootName);
void SetupBoneHierarchyPalette(plMaxBoneMap *bones = nil);
void SetDISceneNodeSpans( plDrawInterface *di, hsBool needBlending );
void SetDISceneNodeSpans( plDrawInterface *di, bool needBlending );
hsBool IsLegalDecal(hsBool checkParent = true);
bool IsLegalDecal(bool checkParent = true);
bool IsAnimatedLight();
@ -170,9 +170,9 @@ public:
// indices to sound objects attached to the node
uint32_t GetNextSoundIdx( void );
hsBool IsPhysical( void );
bool IsPhysical( void );
hsBool CanMakeMesh( Object *obj, plErrorMsg *pErrMsg, plConvertSettings *settings );
bool CanMakeMesh( Object *obj, plErrorMsg *pErrMsg, plConvertSettings *settings );
plDrawInterface* GetDrawInterface(); // Returns nil if there isn't a sceneobject and a drawinterface.
// Only call during convert
@ -187,12 +187,12 @@ public:
protected:
INode *GetRootNode() { return GetInterface()->GetRootNode(); }
plDrawableSpans *IGetSceneNodeSpans( plSceneNode *node, hsBool needBlending, hsBool needSorting=true );
plDrawableSpans *IGetSceneNodeSpans( plSceneNode *node, bool needBlending, bool needSorting=true );
plLightInfo* IMakeDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeOmni(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeSpot(plErrorMsg* pErrMsg, plConvertSettings* settings);
hsBool IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg);
bool IGetProjection(plLightInfo* li, plErrorMsg* pErrMsg);
plLightInfo* IMakeRTDirectional(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeRTOmni(plErrorMsg* pErrMsg, plConvertSettings* settings);
plLightInfo* IMakeRTSpot(plErrorMsg* pErrMsg, plConvertSettings* settings);
@ -206,9 +206,9 @@ protected:
void IGetRTLightColors(plLightInfo* liInfo, IParamBlock2* ProperPB);
void IGetRTLightAttenuation(plOmniLightInfo* liInfo, IParamBlock2* ProperPB);
// RunTime Light animation builders
hsBool IGetRTLightAttenValues(IParamBlock2* ProperPB, float& attenConst, float& attenLinear, float& attenQuadratic,float &attenCutoff);
bool IGetRTLightAttenValues(IParamBlock2* ProperPB, float& attenConst, float& attenLinear, float& attenQuadratic,float &attenCutoff);
void IAdjustRTColorByIntensity(plController* ctl, IParamBlock2* ProperPB);
hsBool IAttachRTLightModifier(plLightModifier* liMod);
bool IAttachRTLightModifier(plLightModifier* liMod);
plLightInfo* IMakeLight(plErrorMsg *pErrMsg, plConvertSettings *settings);
@ -221,14 +221,14 @@ protected:
void ISetupBones( plDrawableSpans *drawable, hsTArray<plGeometrySpan *> &spanArray,
hsMatrix44 &l2w, hsMatrix44 &w2l,
plErrorMsg *pErrMsg, plConvertSettings *settings );
hsBool IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings);
bool IFindBones(plErrorMsg *pErrMsg, plConvertSettings *settings);
void IWipeBranchDrawable(hsBool b);
void IWipeBranchDrawable(bool b);
uint32_t IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, hsBool beMoreAccurate = false );
hsBool IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan *> &spanArray,
uint32_t IBuildInstanceList( Object *obj, TimeValue t, hsTArray<plMaxNode *> &nodes, bool beMoreAccurate = false );
bool IMakeInstanceSpans( plMaxNode *node, hsTArray<plGeometrySpan *> &spanArray,
plErrorMsg *pErrMsg, plConvertSettings *settings );
hsBool IMaterialsMatch( plMaxNode *otherNode, hsBool beMoreAccurate );
bool IMaterialsMatch( plMaxNode *otherNode, bool beMoreAccurate );
int IGetCachedAlphaHackValue( int iSubMtl );
void ISetCachedAlphaHackValue( int iSubMtl, int value );

222
Sources/Tools/MaxMain/plMaxNodeBase.cpp
View File

@ -125,60 +125,60 @@ plMaxNodeData *plMaxNodeBase::GetMaxNodeData()
plKey plMaxNodeBase::GetKey() { GetMD; return (pMD) ? pMD->GetKey() : nil; }
plSceneObject* plMaxNodeBase::GetSceneObject() { GetMD; return (pMD) ? pMD->GetSceneObject() : nil;}
hsBool plMaxNodeBase::GetForceLocal() { GetMD; return (pMD) ? pMD->GetForceLocal() : nil; }
hsBool plMaxNodeBase::GetReverseSort() { GetMD; return (pMD) ? pMD->GetReverseSort() : nil;}
hsBool plMaxNodeBase::GetSortAsOpaque() { GetMD; return (pMD) ? pMD->GetSortAsOpaque() : nil;}
hsBool plMaxNodeBase::GetVS() { GetMD; return (pMD) ? pMD->GetVS() : nil;}
hsBool plMaxNodeBase::GetHasWaterHeight() { GetMD; return (pMD) ? pMD->GetHasWaterHeight() : nil; }
float plMaxNodeBase::GetWaterHeight() { GetMD; return (pMD) ? pMD->GetWaterHeight() : nil; }
hsBool plMaxNodeBase::GetSmoothAll() { GetMD; return (pMD) ? pMD->GetSmoothAll() : nil;}
hsBool plMaxNodeBase::GetForceSortable() { GetMD; return (pMD) ? pMD->GetForceSortable() : nil;}
hsBool plMaxNodeBase::GetConcave() { GetMD; return (pMD) ? pMD->GetConcave() : nil;}
hsBool plMaxNodeBase::GetCalcEdgeLens() { GetMD; return (pMD) ? pMD->GetCalcEdgeLens() : nil;}
hsBool plMaxNodeBase::GetRunTimeLight() { GetMD; return (pMD) ? pMD->GetRunTimeLight() : nil;}
hsBool plMaxNodeBase::GetForceMatShade() { GetMD; return (pMD) ? pMD->GetForceMatShade() : nil;}
hsBool plMaxNodeBase::GetForceVisLOS() { GetMD; return (pMD) ? pMD->GetForceVisLOS() : nil;}
hsBool plMaxNodeBase::GetEnviron() { GetMD; return (pMD) ? pMD->GetEnviron() : nil;}
hsBool plMaxNodeBase::GetEnvironOnly() { GetMD; return (pMD) ? pMD->GetEnvironOnly() : nil;}
hsBool plMaxNodeBase::GetWaterDecEnv() { GetMD; return (pMD) ? pMD->GetWaterDecEnv() : nil; }
hsBool plMaxNodeBase::GetNoPreShade() { GetMD; return (pMD) ? pMD->GetNoPreShade() && !pMD->GetForcePreShade() : nil;}
hsBool plMaxNodeBase::GetForcePreShade() { GetMD; return (pMD) ? pMD->GetForcePreShade() : nil;}
bool plMaxNodeBase::GetForceLocal() { GetMD; return (pMD) ? pMD->GetForceLocal() : nil; }
bool plMaxNodeBase::GetReverseSort() { GetMD; return (pMD) ? pMD->GetReverseSort() : nil;}
bool plMaxNodeBase::GetSortAsOpaque() { GetMD; return (pMD) ? pMD->GetSortAsOpaque() : nil;}
bool plMaxNodeBase::GetVS() { GetMD; return (pMD) ? pMD->GetVS() : nil;}
bool plMaxNodeBase::GetHasWaterHeight() { GetMD; return (pMD) ? pMD->GetHasWaterHeight() : nil; }
float plMaxNodeBase::GetWaterHeight() { GetMD; return (pMD) ? pMD->GetWaterHeight() : nil; }
bool plMaxNodeBase::GetSmoothAll() { GetMD; return (pMD) ? pMD->GetSmoothAll() : nil;}
bool plMaxNodeBase::GetForceSortable() { GetMD; return (pMD) ? pMD->GetForceSortable() : nil;}
bool plMaxNodeBase::GetConcave() { GetMD; return (pMD) ? pMD->GetConcave() : nil;}
bool plMaxNodeBase::GetCalcEdgeLens() { GetMD; return (pMD) ? pMD->GetCalcEdgeLens() : nil;}
bool plMaxNodeBase::GetRunTimeLight() { GetMD; return (pMD) ? pMD->GetRunTimeLight() : nil;}
bool plMaxNodeBase::GetForceMatShade() { GetMD; return (pMD) ? pMD->GetForceMatShade() : nil;}
bool plMaxNodeBase::GetForceVisLOS() { GetMD; return (pMD) ? pMD->GetForceVisLOS() : nil;}
bool plMaxNodeBase::GetEnviron() { GetMD; return (pMD) ? pMD->GetEnviron() : nil;}
bool plMaxNodeBase::GetEnvironOnly() { GetMD; return (pMD) ? pMD->GetEnvironOnly() : nil;}
bool plMaxNodeBase::GetWaterDecEnv() { GetMD; return (pMD) ? pMD->GetWaterDecEnv() : nil; }
bool plMaxNodeBase::GetNoPreShade() { GetMD; return (pMD) ? pMD->GetNoPreShade() && !pMD->GetForcePreShade() : nil;}
bool plMaxNodeBase::GetForcePreShade() { GetMD; return (pMD) ? pMD->GetForcePreShade() : nil;}
plKey plMaxNodeBase::GetRoomKey() { GetMD; return (pMD) ? pMD->GetRoomKey() : nil; }
hsBool plMaxNodeBase::GetDrawable() { GetMD; return (pMD) ? pMD->GetDrawable() : nil; }
hsBool plMaxNodeBase::GetPhysical() { GetMD; return (pMD) ? pMD->GetPhysical() : nil; }
hsBool plMaxNodeBase::GetItinerant() { GetMD; return (pMD) ? pMD->GetItinerant() : nil; }
hsBool plMaxNodeBase::GetUnBounded() { GetMD; return (pMD) ? pMD->GetUnBounded() : nil; }
hsBool plMaxNodeBase::GetDisableNormal() { GetMD; return (pMD) ? pMD->GetDisableNormal() : nil; }
uint32_t plMaxNodeBase::GetDecalLevel() { GetMD; return (pMD) ? pMD->GetDecalLevel() : nil; }
hsBool plMaxNodeBase::GetMovable() { GetMD; return (pMD) ? pMD->GetMovable() : nil; }
hsBool plMaxNodeBase::GetIsBarney() { GetMD; return (pMD) ? pMD->GetIsBarney() : nil; }
hsBool plMaxNodeBase::GetForceShadow() { GetMD; return (pMD) ? pMD->GetForceShadow() : nil; }
hsBool plMaxNodeBase::GetAlphaTestHigh() { GetMD; return (pMD) ? pMD->GetAlphaTestHigh() : nil; }
hsBool plMaxNodeBase::GetFilterInherit() { GetMD; return (pMD) ? pMD->GetFilterInherit() : nil; }
hsBool plMaxNodeBase::GetNoShadow() { GetMD; return (pMD) ? pMD->GetNoShadow() : nil; }
hsBool plMaxNodeBase::GetNoSpanSort() { GetMD; return (pMD) ? pMD->GetNoSpanSort() : nil; }
hsBool plMaxNodeBase::GetNoSpanReSort() { GetMD; return (pMD) ? pMD->GetNoSpanReSort() : nil; }
hsBool plMaxNodeBase::GetNoFaceSort() { GetMD; return (pMD) ? pMD->GetNoFaceSort() : nil; }
hsBool plMaxNodeBase::GetNoDeferDraw() { GetMD; return (pMD) ? pMD->GetNoDeferDraw() : nil; }
hsBool plMaxNodeBase::GetBlendToFB() { GetMD; return (pMD) ? pMD->GetBlendToFB() : nil; }
hsBool plMaxNodeBase::GetForceMaterialCopy() { GetMD; return (pMD) ? pMD->GetForceMaterialCopy() : nil; }
hsBool plMaxNodeBase::GetInstanced() { GetMD; return (pMD) ? pMD->GetInstanced() : nil; }
hsBool plMaxNodeBase::GetParticleRelated() { GetMD; return (pMD) ? pMD->GetParticleRelated() : nil; }
uint32_t plMaxNodeBase::GetSoundIdxCounter() { GetMD; return (pMD) ? pMD->GetSoundIdxCounter() : 0; }
bool plMaxNodeBase::GetDrawable() { GetMD; return (pMD) ? pMD->GetDrawable() : nil; }
bool plMaxNodeBase::GetPhysical() { GetMD; return (pMD) ? pMD->GetPhysical() : nil; }
bool plMaxNodeBase::GetItinerant() { GetMD; return (pMD) ? pMD->GetItinerant() : nil; }
bool plMaxNodeBase::GetUnBounded() { GetMD; return (pMD) ? pMD->GetUnBounded() : nil; }
bool plMaxNodeBase::GetDisableNormal() { GetMD; return (pMD) ? pMD->GetDisableNormal() : nil; }
uint32_t plMaxNodeBase::GetDecalLevel() { GetMD; return (pMD) ? pMD->GetDecalLevel() : nil; }
bool plMaxNodeBase::GetMovable() { GetMD; return (pMD) ? pMD->GetMovable() : nil; }
bool plMaxNodeBase::GetIsBarney() { GetMD; return (pMD) ? pMD->GetIsBarney() : nil; }
bool plMaxNodeBase::GetForceShadow() { GetMD; return (pMD) ? pMD->GetForceShadow() : nil; }
bool plMaxNodeBase::GetAlphaTestHigh() { GetMD; return (pMD) ? pMD->GetAlphaTestHigh() : nil; }
bool plMaxNodeBase::GetFilterInherit() { GetMD; return (pMD) ? pMD->GetFilterInherit() : nil; }
bool plMaxNodeBase::GetNoShadow() { GetMD; return (pMD) ? pMD->GetNoShadow() : nil; }
bool plMaxNodeBase::GetNoSpanSort() { GetMD; return (pMD) ? pMD->GetNoSpanSort() : nil; }
bool plMaxNodeBase::GetNoSpanReSort() { GetMD; return (pMD) ? pMD->GetNoSpanReSort() : nil; }
bool plMaxNodeBase::GetNoFaceSort() { GetMD; return (pMD) ? pMD->GetNoFaceSort() : nil; }
bool plMaxNodeBase::GetNoDeferDraw() { GetMD; return (pMD) ? pMD->GetNoDeferDraw() : nil; }
bool plMaxNodeBase::GetBlendToFB() { GetMD; return (pMD) ? pMD->GetBlendToFB() : nil; }
bool plMaxNodeBase::GetForceMaterialCopy() { GetMD; return (pMD) ? pMD->GetForceMaterialCopy() : nil; }
bool plMaxNodeBase::GetInstanced() { GetMD; return (pMD) ? pMD->GetInstanced() : nil; }
bool plMaxNodeBase::GetParticleRelated() { GetMD; return (pMD) ? pMD->GetParticleRelated() : nil; }
uint32_t plMaxNodeBase::GetSoundIdxCounter() { GetMD; return (pMD) ? pMD->GetSoundIdxCounter() : 0; }
plSceneObject* plMaxNodeBase::GetAvatarSO() { GetMD; return (pMD) ? pMD->GetAvatarSO() : nil; }
BOOL plMaxNodeBase::HasFade() { GetMD; return (pMD) ? pMD->HasFade() : false; }
Box3 plMaxNodeBase::GetFade() { GetMD; return (pMD) ? pMD->GetFade() : Box3(Point3(0,0,0), Point3(0,0,0)); }
hsBool plMaxNodeBase::GetDup2Sided() { GetMD; return (pMD) ? pMD->GetDup2Sided() : false;}
hsBool plMaxNodeBase::GetRadiateNorms() { GetMD; return (pMD) ? pMD->GetRadiateNorms() : false;}
bool plMaxNodeBase::GetDup2Sided() { GetMD; return (pMD) ? pMD->GetDup2Sided() : false;}
bool plMaxNodeBase::GetRadiateNorms() { GetMD; return (pMD) ? pMD->GetRadiateNorms() : false;}
BOOL plMaxNodeBase::HasNormalChan() { GetMD; return (pMD) ? pMD->HasNormalChan() : false; }
int plMaxNodeBase::GetNormalChan() { GetMD; return (pMD) ? pMD->GetNormalChan() : 0; }
hsBool plMaxNodeBase::GetIsGUI() { GetMD; return (pMD) ? pMD->GetIsGUI() : false; }
bool plMaxNodeBase::GetIsGUI() { GetMD; return (pMD) ? pMD->GetIsGUI() : false; }
plSharedMesh* plMaxNodeBase::GetSwappableGeom() { GetMD; return (pMD) ? pMD->GetSwappableGeom() : nil; }
uint32_t plMaxNodeBase::GetSwappableGeomTarget() { GetMD; return (pMD) ? pMD->GetSwappableGeomTarget() : -1; }
uint32_t plMaxNodeBase::GetSwappableGeomTarget() { GetMD; return (pMD) ? pMD->GetSwappableGeomTarget() : -1; }
plMaxBoneMap* plMaxNodeBase::GetBoneMap() { GetMD; return (pMD) ? pMD->GetBoneMap() : nil; }
hsBool plMaxNodeBase::GetOverrideHighLevelSDL() { GetMD; return (pMD) ? pMD->GetOverrideHighLevelSDL() : false; }
uint8_t plMaxNodeBase::GetAnimCompress() { GetMD; return (pMD) ? pMD->GetAnimCompress() : false; }
float plMaxNodeBase::GetKeyReduceThreshold() { GetMD; return (pMD) ? pMD->GetKeyReduceThreshold() : 0; }
bool plMaxNodeBase::GetOverrideHighLevelSDL() { GetMD; return (pMD) ? pMD->GetOverrideHighLevelSDL() : false; }
uint8_t plMaxNodeBase::GetAnimCompress() { GetMD; return (pMD) ? pMD->GetAnimCompress() : false; }
float plMaxNodeBase::GetKeyReduceThreshold() { GetMD; return (pMD) ? pMD->GetKeyReduceThreshold() : 0; }
int plMaxNodeBase::NumRenderDependencies() { GetMD; return (pMD) ? pMD->NumRenderDependencies() : 0; }
plMaxNodeBase* plMaxNodeBase::GetRenderDependency(int i) { GetMD; return (pMD) ? pMD->GetRenderDependency(i) : nil; }
@ -189,58 +189,58 @@ plMaxNodeBase* plMaxNodeBase::GetBone(int i) { GetMD; ret
//------------------------------
// Set Data from MaxNodeData
//------------------------------
void plMaxNodeBase::SetCanConvert(hsBool b) { GetMD; pMD->SetCanConvert(b); }
void plMaxNodeBase::SetCanConvert(bool b) { GetMD; pMD->SetCanConvert(b); }
void plMaxNodeBase::SetMesh(hsGMesh *p) { GetMD; pMD->SetMesh(p); }
void plMaxNodeBase::SetRoomKey(plKey p) { GetMD; pMD->SetRoomKey(p); }
void plMaxNodeBase::SetDrawable(hsBool b) { GetMD; pMD->SetDrawable(b); }
void plMaxNodeBase::SetPhysical(hsBool b) { GetMD; pMD->SetPhysical(b); }
//void plMaxNodeBase::SetItinerant(hsBool b);
void plMaxNodeBase::SetUnBounded(hsBool b) { GetMD; pMD->SetUnBounded(b); }
void plMaxNodeBase::SetDisableNormal(hsBool b) { GetMD; pMD->SetDisableNormal(b); }
void plMaxNodeBase::SetDrawable(bool b) { GetMD; pMD->SetDrawable(b); }
void plMaxNodeBase::SetPhysical(bool b) { GetMD; pMD->SetPhysical(b); }
//void plMaxNodeBase::SetItinerant(bool b);
void plMaxNodeBase::SetUnBounded(bool b) { GetMD; pMD->SetUnBounded(b); }
void plMaxNodeBase::SetDisableNormal(bool b) { GetMD; pMD->SetDisableNormal(b); }
void plMaxNodeBase::SetDecalLevel(uint32_t i) { GetMD; pMD->SetDecalLevel(i); }
void plMaxNodeBase::SetMovable(hsBool b) { GetMD; pMD->SetMovable(b); pMD->SetRunTimeLight(b); pMD->SetNoPreShade(b); }
void plMaxNodeBase::SetReverseSort(hsBool b) { GetMD; pMD->SetReverseSort(b); }
void plMaxNodeBase::SetSortAsOpaque(hsBool b) { GetMD; pMD->SetSortAsOpaque(b); }
void plMaxNodeBase::SetVS(hsBool b) { GetMD; pMD->SetVS(b); }
void plMaxNodeBase::SetHasWaterHeight(hsBool b) { GetMD; pMD->SetHasWaterHeight(b); }
void plMaxNodeBase::SetMovable(bool b) { GetMD; pMD->SetMovable(b); pMD->SetRunTimeLight(b); pMD->SetNoPreShade(b); }
void plMaxNodeBase::SetReverseSort(bool b) { GetMD; pMD->SetReverseSort(b); }
void plMaxNodeBase::SetSortAsOpaque(bool b) { GetMD; pMD->SetSortAsOpaque(b); }
void plMaxNodeBase::SetVS(bool b) { GetMD; pMD->SetVS(b); }
void plMaxNodeBase::SetHasWaterHeight(bool b) { GetMD; pMD->SetHasWaterHeight(b); }
void plMaxNodeBase::SetWaterHeight(float h) { GetMD; pMD->SetWaterHeight(h); }
void plMaxNodeBase::SetSmoothAll(hsBool b) { GetMD; pMD->SetSmoothAll(b); }
void plMaxNodeBase::SetForceSortable(hsBool b) { GetMD; pMD->SetForceSortable(b); }
void plMaxNodeBase::SetConcave(hsBool b) { GetMD; pMD->SetConcave(b); }
void plMaxNodeBase::SetCalcEdgeLens(hsBool b) { GetMD; pMD->SetCalcEdgeLens(b); }
void plMaxNodeBase::SetRunTimeLight(hsBool b) { GetMD; pMD->SetRunTimeLight(b); }
void plMaxNodeBase::SetForceMatShade(hsBool b) { GetMD; pMD->SetForceMatShade(b); }
void plMaxNodeBase::SetForceVisLOS(hsBool b) { GetMD; pMD->SetForceVisLOS(b); }
void plMaxNodeBase::SetEnviron(hsBool b) { GetMD; pMD->SetEnviron(b); }
void plMaxNodeBase::SetEnvironOnly(hsBool b) { GetMD; pMD->SetEnvironOnly(b); }
void plMaxNodeBase::SetWaterDecEnv(hsBool b) { GetMD; pMD->SetWaterDecEnv(b); }
void plMaxNodeBase::SetNoPreShade(hsBool b) { GetMD; pMD->SetNoPreShade(b); }
void plMaxNodeBase::SetForcePreShade(hsBool b) { GetMD; pMD->SetForcePreShade(b); }
void plMaxNodeBase::SetForceLocal(hsBool b) { GetMD; pMD->SetForceLocal(b); }
void plMaxNodeBase::SetIsBarney(hsBool b) { GetMD; pMD->SetIsBarney(b); }
void plMaxNodeBase::SetForceShadow(hsBool b) { GetMD; pMD->SetForceShadow(b); }
void plMaxNodeBase::SetAlphaTestHigh(hsBool b) { GetMD; pMD->SetAlphaTestHigh(b); }
void plMaxNodeBase::SetFilterInherit(hsBool b) { GetMD; pMD->SetFilterInherit(b); }
void plMaxNodeBase::SetNoShadow(hsBool b) { GetMD; pMD->SetNoShadow(b); }
void plMaxNodeBase::SetNoSpanSort(hsBool b) { GetMD; pMD->SetNoSpanSort(b); }
void plMaxNodeBase::SetNoSpanReSort(hsBool b) { GetMD; pMD->SetNoSpanReSort(b); }
void plMaxNodeBase::SetNoFaceSort(hsBool b) { GetMD; pMD->SetNoFaceSort(b); }
void plMaxNodeBase::SetNoDeferDraw(hsBool b) { GetMD; pMD->SetNoDeferDraw(b); }
void plMaxNodeBase::SetBlendToFB(hsBool b) { GetMD; pMD->SetBlendToFB(b); }
void plMaxNodeBase::SetForceMaterialCopy(hsBool b) { GetMD; pMD->SetForceMaterialCopy(b); }
void plMaxNodeBase::SetInstanced(hsBool b) { GetMD; pMD->SetInstanced(b); }
void plMaxNodeBase::SetParticleRelated(hsBool b) { GetMD; pMD->SetParticleRelated(b); }
void plMaxNodeBase::SetSmoothAll(bool b) { GetMD; pMD->SetSmoothAll(b); }
void plMaxNodeBase::SetForceSortable(bool b) { GetMD; pMD->SetForceSortable(b); }
void plMaxNodeBase::SetConcave(bool b) { GetMD; pMD->SetConcave(b); }
void plMaxNodeBase::SetCalcEdgeLens(bool b) { GetMD; pMD->SetCalcEdgeLens(b); }
void plMaxNodeBase::SetRunTimeLight(bool b) { GetMD; pMD->SetRunTimeLight(b); }
void plMaxNodeBase::SetForceMatShade(bool b) { GetMD; pMD->SetForceMatShade(b); }
void plMaxNodeBase::SetForceVisLOS(bool b) { GetMD; pMD->SetForceVisLOS(b); }
void plMaxNodeBase::SetEnviron(bool b) { GetMD; pMD->SetEnviron(b); }
void plMaxNodeBase::SetEnvironOnly(bool b) { GetMD; pMD->SetEnvironOnly(b); }
void plMaxNodeBase::SetWaterDecEnv(bool b) { GetMD; pMD->SetWaterDecEnv(b); }
void plMaxNodeBase::SetNoPreShade(bool b) { GetMD; pMD->SetNoPreShade(b); }
void plMaxNodeBase::SetForcePreShade(bool b) { GetMD; pMD->SetForcePreShade(b); }
void plMaxNodeBase::SetForceLocal(bool b) { GetMD; pMD->SetForceLocal(b); }
void plMaxNodeBase::SetIsBarney(bool b) { GetMD; pMD->SetIsBarney(b); }
void plMaxNodeBase::SetForceShadow(bool b) { GetMD; pMD->SetForceShadow(b); }
void plMaxNodeBase::SetAlphaTestHigh(bool b) { GetMD; pMD->SetAlphaTestHigh(b); }
void plMaxNodeBase::SetFilterInherit(bool b) { GetMD; pMD->SetFilterInherit(b); }
void plMaxNodeBase::SetNoShadow(bool b) { GetMD; pMD->SetNoShadow(b); }
void plMaxNodeBase::SetNoSpanSort(bool b) { GetMD; pMD->SetNoSpanSort(b); }
void plMaxNodeBase::SetNoSpanReSort(bool b) { GetMD; pMD->SetNoSpanReSort(b); }
void plMaxNodeBase::SetNoFaceSort(bool b) { GetMD; pMD->SetNoFaceSort(b); }
void plMaxNodeBase::SetNoDeferDraw(bool b) { GetMD; pMD->SetNoDeferDraw(b); }
void plMaxNodeBase::SetBlendToFB(bool b) { GetMD; pMD->SetBlendToFB(b); }
void plMaxNodeBase::SetForceMaterialCopy(bool b) { GetMD; pMD->SetForceMaterialCopy(b); }
void plMaxNodeBase::SetInstanced(bool b) { GetMD; pMD->SetInstanced(b); }
void plMaxNodeBase::SetParticleRelated(bool b) { GetMD; pMD->SetParticleRelated(b); }
void plMaxNodeBase::SetSoundIdxCounter(uint32_t ctr) { GetMD; pMD->SetSoundIdxCounter(ctr); }
void plMaxNodeBase::SetAvatarSO(plSceneObject *so) { GetMD; pMD->SetAvatarSO(so); }
void plMaxNodeBase::SetFade(const Box3& b) { GetMD; pMD->SetFade(b); }
void plMaxNodeBase::SetDup2Sided(hsBool b) { GetMD; pMD->SetDup2Sided(b); }
void plMaxNodeBase::SetRadiateNorms(hsBool b) { GetMD; pMD->SetRadiateNorms(b); }
void plMaxNodeBase::SetDup2Sided(bool b) { GetMD; pMD->SetDup2Sided(b); }
void plMaxNodeBase::SetRadiateNorms(bool b) { GetMD; pMD->SetRadiateNorms(b); }
void plMaxNodeBase::SetNormalChan(int n) { GetMD; pMD->SetNormalChan(n); }
void plMaxNodeBase::SetIsGUI(hsBool b) { GetMD; pMD->SetIsGUI(b); }
void plMaxNodeBase::SetIsGUI(bool b) { GetMD; pMD->SetIsGUI(b); }
void plMaxNodeBase::SetSwappableGeom(plSharedMesh *sm) { GetMD; pMD->SetSwappableGeom(sm); }
void plMaxNodeBase::SetSwappableGeomTarget(uint32_t id) { GetMD; pMD->SetSwappableGeomTarget(id); }
void plMaxNodeBase::SetBoneMap(plMaxBoneMap *bones) { GetMD; pMD->SetBoneMap(bones); }
void plMaxNodeBase::SetOverrideHighLevelSDL(hsBool b) { GetMD; pMD->SetOverrideHighLevelSDL(b); }
void plMaxNodeBase::SetOverrideHighLevelSDL(bool b) { GetMD; pMD->SetOverrideHighLevelSDL(b); }
void plMaxNodeBase::SetAnimCompress(uint8_t v) { GetMD; pMD->SetAnimCompress(v); }
void plMaxNodeBase::SetKeyReduceThreshold(float v) { GetMD; pMD->SetKeyReduceThreshold(v); }
void plMaxNodeBase::ClearRenderDependencies() { GetMD; pMD->ClearRenderDependencies(); }
@ -258,13 +258,13 @@ plLocation plMaxNodeBase::GetLocation()
return loc;
}
hsBool plMaxNodeBase::GetDirty(uint8_t i)
bool plMaxNodeBase::GetDirty(uint8_t i)
{
uint8_t *dirty = IGetSceneViewerChunk();
return *dirty & i;
}
void plMaxNodeBase::SetDirty(uint8_t i, hsBool b)
void plMaxNodeBase::SetDirty(uint8_t i, bool b)
{
uint8_t *dirty = IGetSceneViewerChunk();
@ -274,7 +274,7 @@ void plMaxNodeBase::SetDirty(uint8_t i, hsBool b)
*dirty &= ~i;
}
hsBool plMaxNodeBase::HasLoadMask()
bool plMaxNodeBase::HasLoadMask()
{
GetMD;
return pMD->HasLoadMask();
@ -292,7 +292,7 @@ void plMaxNodeBase::AddLoadMask(const plLoadMask& m)
pMD->AddLoadMask(m);
}
hsBool plMaxNodeBase::RenderDependsOn(plMaxNodeBase* m)
bool plMaxNodeBase::RenderDependsOn(plMaxNodeBase* m)
{
if( m == this )
return true;
@ -306,7 +306,7 @@ hsBool plMaxNodeBase::RenderDependsOn(plMaxNodeBase* m)
return false;
}
hsBool plMaxNodeBase::AddRenderDependency(plMaxNodeBase* m)
bool plMaxNodeBase::AddRenderDependency(plMaxNodeBase* m)
{
if( m->RenderDependsOn(this) )
return false;
@ -334,7 +334,7 @@ uint8_t *plMaxNodeBase::IGetSceneViewerChunk()
return SVChunk;
}
hsBool plMaxNodeBase::CanConvert(bool recalculate)
bool plMaxNodeBase::CanConvert(bool recalculate)
{
// Try and find a cached return value
plMaxNodeData *md = GetMaxNodeData();
@ -365,17 +365,17 @@ hsBool plMaxNodeBase::CanConvert(bool recalculate)
return false;
}
hsBool plMaxNodeBase::IsTMAnimated()
bool plMaxNodeBase::IsTMAnimated()
{
Control* tmControl = GetTMController();
return (tmControl && tmControl->IsAnimated());
}
//// IsTMAnimatedRecur - test recursively up the chain ///////////////////////////////////////////////////////////////
hsBool plMaxNodeBase::IsTMAnimatedRecur()
bool plMaxNodeBase::IsTMAnimatedRecur()
{
const char* dbgNodeName = GetName();
hsBool shouldBe = false;
bool shouldBe = false;
if( !CanConvert() )
return false;
@ -387,10 +387,10 @@ hsBool plMaxNodeBase::IsTMAnimatedRecur()
//// IsMovable ///////////////////////////////////////////////////////////////
// Returns whether this node is "animated" (i.e. could move at runtime)
hsBool plMaxNodeBase::IsMovable()
bool plMaxNodeBase::IsMovable()
{
const char* dbgNodeName = GetName();
hsBool shouldBe = false;
bool shouldBe = false;
if( !CanConvert() )
@ -419,7 +419,7 @@ hsBool plMaxNodeBase::IsMovable()
}
// Recursively set so we don't have to recursively check.
void plMaxNodeBase::SetItinerant(hsBool b)
void plMaxNodeBase::SetItinerant(bool b)
{
const char* dbgNodeName = GetName();
@ -495,7 +495,7 @@ bool plMaxNodeBase::IsXRef()
return false;
}
hsBool plMaxNodeBase::IsComponent(Object *obj)
bool plMaxNodeBase::IsComponent(Object *obj)
{
if (!obj)
obj = GetObjectRef();
@ -506,7 +506,7 @@ hsBool plMaxNodeBase::IsComponent(Object *obj)
return false;
}
hsBool plMaxNodeBase::IsExternComponent(Object *obj)
bool plMaxNodeBase::IsExternComponent(Object *obj)
{
if (!obj)
obj = GetObjectRef();
@ -623,7 +623,7 @@ plComponentBase *plMaxNodeBase::IRefMakerToComponent(ReferenceMaker *maker, bool
return nil;
}
hsBool plMaxNodeBase::IRenderLevelSet(hsBool forBlend)
bool plMaxNodeBase::IRenderLevelSet(bool forBlend)
{
plMaxNodeData* md = GetMaxNodeData();
if( md )
@ -631,7 +631,7 @@ hsBool plMaxNodeBase::IRenderLevelSet(hsBool forBlend)
return false;
}
void plMaxNodeBase::ISetRenderLevel(const plRenderLevel& l, hsBool forBlend)
void plMaxNodeBase::ISetRenderLevel(const plRenderLevel& l, bool forBlend)
{
plMaxNodeData* md = GetMaxNodeData();
if( md )
@ -643,7 +643,7 @@ void plMaxNodeBase::ISetRenderLevel(const plRenderLevel& l, hsBool forBlend)
}
}
const plRenderLevel& plMaxNodeBase::IGetRenderLevel(hsBool forBlend)
const plRenderLevel& plMaxNodeBase::IGetRenderLevel(bool forBlend)
{
plMaxNodeData* md = GetMaxNodeData();
if( !md )
@ -654,7 +654,7 @@ const plRenderLevel& plMaxNodeBase::IGetRenderLevel(hsBool forBlend)
return forBlend ? md->GetBlendLevel() : md->GetOpaqueLevel();
}
uint32_t plMaxNodeBase::IGetMajorRenderLevel(hsBool forBlend)
uint32_t plMaxNodeBase::IGetMajorRenderLevel(bool forBlend)
{
if( GetBlendToFB() )
return plRenderLevel::kFBMajorLevel;
@ -685,7 +685,7 @@ uint32_t plMaxNodeBase::IGetMajorRenderLevel(hsBool forBlend)
return iMaxDep;
}
uint32_t plMaxNodeBase::IGetMinorRenderLevel(hsBool forBlend)
uint32_t plMaxNodeBase::IGetMinorRenderLevel(bool forBlend)
{
if( GetAvatarSO() )
return plRenderLevel::kAvatarRendMinorLevel;
@ -714,7 +714,7 @@ uint32_t plMaxNodeBase::IGetMinorRenderLevel(hsBool forBlend)
return iMaxDep + 4;
}
plRenderLevel plMaxNodeBase::ICalcRenderLevel(hsBool forBlend)
plRenderLevel plMaxNodeBase::ICalcRenderLevel(bool forBlend)
{
if( GetBlendToFB() )
return plRenderLevel::kFBMajorLevel;
@ -753,7 +753,7 @@ plRenderLevel plMaxNodeBase::ICalcRenderLevel(hsBool forBlend)
return maxLevel;
}
const plRenderLevel& plMaxNodeBase::GetRenderLevel(hsBool forBlend)
const plRenderLevel& plMaxNodeBase::GetRenderLevel(bool forBlend)
{
if( !CanConvert() )
{
@ -805,7 +805,7 @@ void plMaxNodeBase::SetGeoDice(BOOL on, int maxFaces, float maxSize, int minFace
}
}
hsBool plMaxNodeBase::Contains(const Point3& worldPt)
bool plMaxNodeBase::Contains(const Point3& worldPt)
{
TimeValue currTime = 0;//hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(currTime).obj;
@ -837,7 +837,7 @@ hsBool plMaxNodeBase::Contains(const Point3& worldPt)
return false;
}
hsBool retVal = true;
bool retVal = true;
int i;
for( i = 0; i < mesh.getNumFaces(); i++ )
{
@ -866,7 +866,7 @@ hsBool plMaxNodeBase::Contains(const Point3& worldPt)
return false;
}
hsBool plMaxNodeBase::Contains(const Box3& bnd, const Matrix3& l2w)
bool plMaxNodeBase::Contains(const Box3& bnd, const Matrix3& l2w)
{
int i;
for( i = 0; i < 8; i++ )

218
Sources/Tools/MaxMain/plMaxNodeBase.h
View File

@ -86,65 +86,65 @@ public:
// Get Data from MaxNodeData
//------------------------------
// If recalculate is true the cached value is ignored. (Useful in the SceneViewer)
hsBool CanConvert(bool recalculate=false);
bool CanConvert(bool recalculate=false);
plLocation GetLocation();
plKey GetKey();
plSceneObject* GetSceneObject();
hsBool GetForceLocal();
hsBool GetReverseSort();
hsBool GetSortAsOpaque();
hsBool GetRunTimeLight();
hsBool GetForceMatShade();
hsBool GetForceVisLOS();
hsBool GetEnviron();
hsBool GetEnvironOnly();
hsBool GetWaterDecEnv();
hsBool GetVS();
hsBool GetHasWaterHeight();
float GetWaterHeight();
hsBool GetSmoothAll();
hsBool GetForceSortable();
hsBool GetConcave();
hsBool GetCalcEdgeLens();
hsBool GetNoPreShade();
hsBool GetForcePreShade();
bool GetForceLocal();
bool GetReverseSort();
bool GetSortAsOpaque();
bool GetRunTimeLight();
bool GetForceMatShade();
bool GetForceVisLOS();
bool GetEnviron();
bool GetEnvironOnly();
bool GetWaterDecEnv();
bool GetVS();
bool GetHasWaterHeight();
float GetWaterHeight();
bool GetSmoothAll();
bool GetForceSortable();
bool GetConcave();
bool GetCalcEdgeLens();
bool GetNoPreShade();
bool GetForcePreShade();
plKey GetRoomKey();
hsBool GetDrawable();
hsBool GetPhysical();
hsBool GetItinerant();
hsBool GetUnBounded();
hsBool GetDisableNormal();
uint32_t GetDecalLevel();
hsBool GetMovable();
hsBool GetNoShadow();
hsBool GetForceShadow();
hsBool GetAlphaTestHigh();
hsBool GetFilterInherit();
hsBool GetIsBarney();
hsBool GetNoSpanSort();
hsBool GetNoSpanReSort();
hsBool GetNoFaceSort();
hsBool GetNoDeferDraw();
hsBool GetBlendToFB();
hsBool GetForceMaterialCopy();
hsBool GetInstanced();
hsBool GetParticleRelated();
uint32_t GetSoundIdxCounter();
bool GetDrawable();
bool GetPhysical();
bool GetItinerant();
bool GetUnBounded();
bool GetDisableNormal();
uint32_t GetDecalLevel();
bool GetMovable();
bool GetNoShadow();
bool GetForceShadow();
bool GetAlphaTestHigh();
bool GetFilterInherit();
bool GetIsBarney();
bool GetNoSpanSort();
bool GetNoSpanReSort();
bool GetNoFaceSort();
bool GetNoDeferDraw();
bool GetBlendToFB();
bool GetForceMaterialCopy();
bool GetInstanced();
bool GetParticleRelated();
uint32_t GetSoundIdxCounter();
plSceneObject* GetAvatarSO();
BOOL HasFade();
Box3 GetFade();
hsBool GetDup2Sided();
hsBool GetRadiateNorms();
bool GetDup2Sided();
bool GetRadiateNorms();
BOOL HasNormalChan();
int GetNormalChan();
BOOL GetGeoDice(int& maxFaces, float& maxSize, int& minFaces);
hsBool GetIsGUI();
bool GetIsGUI();
plSharedMesh* GetSwappableGeom();
uint32_t GetSwappableGeomTarget();
uint32_t GetSwappableGeomTarget();
plMaxBoneMap* GetBoneMap();
hsBool GetOverrideHighLevelSDL();
uint8_t GetAnimCompress();
float GetKeyReduceThreshold();
bool GetOverrideHighLevelSDL();
uint8_t GetAnimCompress();
float GetKeyReduceThreshold();
int NumRenderDependencies();
plMaxNodeBase* GetRenderDependency(int i);
@ -154,63 +154,63 @@ public:
//------------------------------
// Set Data from MaxNodeData
//------------------------------
void SetCanConvert(hsBool b);
void SetCanConvert(bool b);
void SetMesh(hsGMesh *p);
void SetRoomKey(plKey p);
void SetDrawable(hsBool b);
void SetPhysical(hsBool b);
void SetItinerant(hsBool b);
void SetUnBounded(hsBool b);
void SetDisableNormal(hsBool b);
void SetDrawable(bool b);
void SetPhysical(bool b);
void SetItinerant(bool b);
void SetUnBounded(bool b);
void SetDisableNormal(bool b);
void SetDecalLevel(uint32_t i);
void SetMovable(hsBool b);
void SetNoPreShade(hsBool b);
void SetForcePreShade(hsBool b);
void SetReverseSort(hsBool b);
void SetSortAsOpaque(hsBool b);
void SetVS(hsBool b);
void SetHasWaterHeight(hsBool b);
void SetMovable(bool b);
void SetNoPreShade(bool b);
void SetForcePreShade(bool b);
void SetReverseSort(bool b);
void SetSortAsOpaque(bool b);
void SetVS(bool b);
void SetHasWaterHeight(bool b);
void SetWaterHeight(float h);
void SetSmoothAll(hsBool b);
void SetForceSortable(hsBool b);
void SetConcave(hsBool b);
void SetCalcEdgeLens(hsBool b);
void SetRunTimeLight(hsBool b);
void SetForceMatShade(hsBool b);
void SetForceVisLOS(hsBool b);
void SetEnviron(hsBool b);
void SetEnvironOnly(hsBool b);
void SetWaterDecEnv(hsBool b);
void SetForceLocal(hsBool b);
void SetIsBarney(hsBool b);
void SetForceShadow(hsBool b);
void SetAlphaTestHigh(hsBool b);
void SetFilterInherit(hsBool b);
void SetNoShadow(hsBool b);
void SetNoSpanSort(hsBool b);
void SetNoSpanReSort(hsBool b);
void SetNoFaceSort(hsBool b);
void SetNoDeferDraw(hsBool b);
void SetBlendToFB(hsBool b);
void SetForceMaterialCopy(hsBool b);
void SetInstanced(hsBool b);
void SetParticleRelated(hsBool b);
void SetSmoothAll(bool b);
void SetForceSortable(bool b);
void SetConcave(bool b);
void SetCalcEdgeLens(bool b);
void SetRunTimeLight(bool b);
void SetForceMatShade(bool b);
void SetForceVisLOS(bool b);
void SetEnviron(bool b);
void SetEnvironOnly(bool b);
void SetWaterDecEnv(bool b);
void SetForceLocal(bool b);
void SetIsBarney(bool b);
void SetForceShadow(bool b);
void SetAlphaTestHigh(bool b);
void SetFilterInherit(bool b);
void SetNoShadow(bool b);
void SetNoSpanSort(bool b);
void SetNoSpanReSort(bool b);
void SetNoFaceSort(bool b);
void SetNoDeferDraw(bool b);
void SetBlendToFB(bool b);
void SetForceMaterialCopy(bool b);
void SetInstanced(bool b);
void SetParticleRelated(bool b);
void SetSoundIdxCounter(uint32_t ctr);
void SetAvatarSO(plSceneObject *so);
void SetFade(const Box3& b);
void SetDup2Sided(hsBool b);
void SetRadiateNorms(hsBool b);
void SetDup2Sided(bool b);
void SetRadiateNorms(bool b);
void SetNormalChan(int n);
void SetGeoDice(BOOL on, int maxFaces, float maxSize, int minFaces);
void SetIsGUI(hsBool b);
void SetIsGUI(bool b);
void SetSwappableGeom(plSharedMesh *sm);
void SetSwappableGeomTarget(uint32_t id);
void SetBoneMap(plMaxBoneMap *bones);
void SetOverrideHighLevelSDL(hsBool b);
void SetOverrideHighLevelSDL(bool b);
void SetAnimCompress(uint8_t v);
void SetKeyReduceThreshold(float v);
hsBool AddRenderDependency(plMaxNodeBase* m);
hsBool RenderDependsOn(plMaxNodeBase* m);
bool AddRenderDependency(plMaxNodeBase* m);
bool RenderDependsOn(plMaxNodeBase* m);
void ClearRenderDependencies();
void AddBone(plMaxNodeBase* m);
@ -218,28 +218,28 @@ public:
// Dirty flags for SceneWatcher use
enum { kGeomDirty = 0x1, kMatDirty = 0x2, kAllDirty = 0xFF };
hsBool GetDirty(uint8_t i);
void SetDirty(uint8_t i, hsBool b);
bool GetDirty(uint8_t i);
void SetDirty(uint8_t i, bool b);
plKey GetParentKey() { plMaxNodeBase *pPar = (plMaxNodeBase*)GetParentNode(); hsAssert(pPar, "No Parent"); return pPar->GetKey(); }
ISkin* FindSkinModifier(); // Returns the object's skin modifier if it has one, else nil
const plRenderLevel& GetRenderLevel(hsBool forBlend);
const plRenderLevel& GetRenderLevel(bool forBlend);
hsBool HasLoadMask();
bool HasLoadMask();
plLoadMask GetLoadMask();
void AddLoadMask(const plLoadMask& m);
hsBool IsTMAnimated();
hsBool IsTMAnimatedRecur();
hsBool IsMovable(); // Checks to see whether this node will ever move in the scene
bool IsTMAnimated();
bool IsTMAnimatedRecur();
bool IsMovable(); // Checks to see whether this node will ever move in the scene
bool IsXRef(); // Returns true if object is an XRef or part of an XRef'd scene
//----------
// Component
//----------
hsBool IsComponent(Object *obj=nil); // Object pointer is only necessary for internal use,
hsBool IsExternComponent(Object *obj=nil);
bool IsComponent(Object *obj=nil); // Object pointer is only necessary for internal use,
bool IsExternComponent(Object *obj=nil);
plComponentBase *ConvertToComponent(); // Returns nil if node is not a component
@ -251,10 +251,10 @@ public:
uint32_t NumAttachedComponents(bool all=false);
plComponentBase *GetAttachedComponent(uint32_t i, bool all=false);
hsBool Contains(const Point3& worldPt); // is the world space point inside my (CONVEX) geometry or dummy box?
hsBool Contains(const Box3& bnd, const Matrix3& l2w); // is the box contained entirely inside my (CONVEX) geometry or dummy box?
float BoxVolume(const Box3& bnd, const Matrix3& l2w);
float RegionPriority(); // returns a dominance factor. If a point is in more than one environmental
bool Contains(const Point3& worldPt); // is the world space point inside my (CONVEX) geometry or dummy box?
bool Contains(const Box3& bnd, const Matrix3& l2w); // is the box contained entirely inside my (CONVEX) geometry or dummy box?
float BoxVolume(const Box3& bnd, const Matrix3& l2w);
float RegionPriority(); // returns a dominance factor. If a point is in more than one environmental
// region, the region with highest priority wins.
Interface *GetInterface() { return ::GetCOREInterface(); }
@ -303,13 +303,13 @@ protected:
// Attempts to convert a RefMaker pointer to a component. Returns nil if it is not a component.
plComponentBase *IRefMakerToComponent(ReferenceMaker *maker, bool all);
uint32_t IGetMajorRenderLevel(hsBool forBlend);
uint32_t IGetMinorRenderLevel(hsBool forBlend);
uint32_t IGetMajorRenderLevel(bool forBlend);
uint32_t IGetMinorRenderLevel(bool forBlend);
hsBool IRenderLevelSet(hsBool forBlend);
void ISetRenderLevel(const plRenderLevel& l, hsBool forBlend);
const plRenderLevel& IGetRenderLevel(hsBool forBlend);
plRenderLevel ICalcRenderLevel(hsBool forBlend);
bool IRenderLevelSet(bool forBlend);
void ISetRenderLevel(const plRenderLevel& l, bool forBlend);
const plRenderLevel& IGetRenderLevel(bool forBlend);
plRenderLevel ICalcRenderLevel(bool forBlend);
};
#endif //plMaxNodeBase_inc

182
Sources/Tools/MaxMain/plMaxNodeData.h
View File

@ -154,8 +154,8 @@ public:
}
void DeInit() { delete fBitVector; fBitVector = nil; }
hsBool CanBF(DatBit bitChoice) { return fBitVector->IsBitSet(bitChoice); }
void SetBF(hsBool b, DatBit bitChoice) { fBitVector->SetBit(bitChoice, b); }
bool CanBF(DatBit bitChoice) { return fBitVector->IsBitSet(bitChoice); }
void SetBF(bool b, DatBit bitChoice) { fBitVector->SetBit(bitChoice, b); }
};
@ -219,133 +219,133 @@ public:
plSceneObject * GetSceneObject() { return fpSO; }
void SetSceneObject(plSceneObject *p) { fpSO = p; }
hsBool CanConvert() { return MaxDatBF.CanBF(MaxDatBF.kCanConvert); }
void SetCanConvert(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kCanConvert); }
bool CanConvert() { return MaxDatBF.CanBF(MaxDatBF.kCanConvert); }
void SetCanConvert(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kCanConvert); }
hsBool GetForceLocal() { return MaxDatBF.CanBF(MaxDatBF.kForceLocal); }
void SetForceLocal(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceLocal); }
bool GetForceLocal() { return MaxDatBF.CanBF(MaxDatBF.kForceLocal); }
void SetForceLocal(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceLocal); }
void * GetMesh() { return fpMesh; } // void pointer for header simplicity
void SetMesh(hsGMesh *p) { fpMesh = p; }
hsBool GetDrawable() {return MaxDatBF.CanBF(MaxDatBF.kDrawable); }
void SetDrawable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDrawable); }
bool GetDrawable() {return MaxDatBF.CanBF(MaxDatBF.kDrawable); }
void SetDrawable(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kDrawable); }
hsBool GetPhysical() {return MaxDatBF.CanBF(MaxDatBF.kPhysical); }
void SetPhysical(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kPhysical); }
bool GetPhysical() {return MaxDatBF.CanBF(MaxDatBF.kPhysical); }
void SetPhysical(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kPhysical); }
hsBool GetRunTimeLight() {return MaxDatBF.CanBF(MaxDatBF.kRunTimeLight); }
void SetRunTimeLight(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kRunTimeLight); }
bool GetRunTimeLight() {return MaxDatBF.CanBF(MaxDatBF.kRunTimeLight); }
void SetRunTimeLight(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kRunTimeLight); }
hsBool GetForceMatShade() {return MaxDatBF.CanBF(MaxDatBF.kForceMatShade); }
void SetForceMatShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatShade); }
bool GetForceMatShade() {return MaxDatBF.CanBF(MaxDatBF.kForceMatShade); }
void SetForceMatShade(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatShade); }
hsBool GetForceVisLOS() {return MaxDatBF.CanBF(MaxDatBF.kForceVisLOS); }
void SetForceVisLOS(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceVisLOS); }
bool GetForceVisLOS() {return MaxDatBF.CanBF(MaxDatBF.kForceVisLOS); }
void SetForceVisLOS(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceVisLOS); }
hsBool GetEnviron() {return MaxDatBF.CanBF(MaxDatBF.kEnviron); }
void SetEnviron(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnviron); }
bool GetEnviron() {return MaxDatBF.CanBF(MaxDatBF.kEnviron); }
void SetEnviron(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnviron); }
hsBool GetEnvironOnly() {return MaxDatBF.CanBF(MaxDatBF.kEnvironOnly); }
void SetEnvironOnly(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnvironOnly); }
bool GetEnvironOnly() {return MaxDatBF.CanBF(MaxDatBF.kEnvironOnly); }
void SetEnvironOnly(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kEnvironOnly); }
hsBool GetWaterDecEnv() { return MaxDatBF.CanBF(MaxDatBF.kWaterDecEnv); }
void SetWaterDecEnv(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterDecEnv); }
bool GetWaterDecEnv() { return MaxDatBF.CanBF(MaxDatBF.kWaterDecEnv); }
void SetWaterDecEnv(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterDecEnv); }
hsBool GetItinerant() {return MaxDatBF.CanBF(MaxDatBF.kItinerant); }
void SetItinerant(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kItinerant); }
bool GetItinerant() {return MaxDatBF.CanBF(MaxDatBF.kItinerant); }
void SetItinerant(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kItinerant); }
hsBool GetUnBounded() {return MaxDatBF.CanBF(MaxDatBF.kUnBounded); }
void SetUnBounded(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kUnBounded); }
bool GetUnBounded() {return MaxDatBF.CanBF(MaxDatBF.kUnBounded); }
void SetUnBounded(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kUnBounded); }
hsBool GetDisableNormal() {return MaxDatBF.CanBF(MaxDatBF.kDisableNormal); }
void SetDisableNormal(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDisableNormal); }
bool GetDisableNormal() {return MaxDatBF.CanBF(MaxDatBF.kDisableNormal); }
void SetDisableNormal(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kDisableNormal); }
hsBool GetMovable() {return MaxDatBF.CanBF(MaxDatBF.kMovable); }
void SetMovable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kMovable); }
bool GetMovable() {return MaxDatBF.CanBF(MaxDatBF.kMovable); }
void SetMovable(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kMovable); }
hsBool GetNoPreShade() {return MaxDatBF.CanBF(MaxDatBF.kNoPreShade); }
void SetNoPreShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoPreShade); }
bool GetNoPreShade() {return MaxDatBF.CanBF(MaxDatBF.kNoPreShade); }
void SetNoPreShade(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoPreShade); }
hsBool GetForcePreShade() {return MaxDatBF.CanBF(MaxDatBF.kForcePreShade); }
void SetForcePreShade(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForcePreShade); }
bool GetForcePreShade() {return MaxDatBF.CanBF(MaxDatBF.kForcePreShade); }
void SetForcePreShade(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForcePreShade); }
hsBool GetNoShadow() {return MaxDatBF.CanBF(MaxDatBF.kNoShadow); }
void SetNoShadow(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoShadow); }
bool GetNoShadow() {return MaxDatBF.CanBF(MaxDatBF.kNoShadow); }
void SetNoShadow(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoShadow); }
hsBool GetForceShadow() {return MaxDatBF.CanBF(MaxDatBF.kForceShadow); }
void SetForceShadow(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceShadow); }
bool GetForceShadow() {return MaxDatBF.CanBF(MaxDatBF.kForceShadow); }
void SetForceShadow(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceShadow); }
hsBool GetAlphaTestHigh() {return MaxDatBF.CanBF(MaxDatBF.kAlphaTestHigh); }
void SetAlphaTestHigh(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kAlphaTestHigh); }
bool GetAlphaTestHigh() {return MaxDatBF.CanBF(MaxDatBF.kAlphaTestHigh); }
void SetAlphaTestHigh(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kAlphaTestHigh); }
hsBool GetFilterInherit() {return MaxDatBF.CanBF(MaxDatBF.kFilterInherit); }
void SetFilterInherit(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kFilterInherit); }
bool GetFilterInherit() {return MaxDatBF.CanBF(MaxDatBF.kFilterInherit); }
void SetFilterInherit(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kFilterInherit); }
hsBool GetIsBarney() {return MaxDatBF.CanBF(MaxDatBF.kIsBarney); }
void SetIsBarney(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsBarney); }
bool GetIsBarney() {return MaxDatBF.CanBF(MaxDatBF.kIsBarney); }
void SetIsBarney(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsBarney); }
hsBool GetNoSpanSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanSort); }
void SetNoSpanSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanSort); }
bool GetNoSpanSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanSort); }
void SetNoSpanSort(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanSort); }
hsBool GetNoSpanReSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanReSort); }
void SetNoSpanReSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanReSort); }
bool GetNoSpanReSort() {return MaxDatBF.CanBF(MaxDatBF.kNoSpanReSort); }
void SetNoSpanReSort(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoSpanReSort); }
hsBool GetNoFaceSort() {return MaxDatBF.CanBF(MaxDatBF.kNoFaceSort); }
void SetNoFaceSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoFaceSort); }
bool GetNoFaceSort() {return MaxDatBF.CanBF(MaxDatBF.kNoFaceSort); }
void SetNoFaceSort(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoFaceSort); }
hsBool GetReverseSort() {return MaxDatBF.CanBF(MaxDatBF.kReverseSort); }
void SetReverseSort(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kReverseSort); }
bool GetReverseSort() {return MaxDatBF.CanBF(MaxDatBF.kReverseSort); }
void SetReverseSort(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kReverseSort); }
hsBool GetSortAsOpaque() {return MaxDatBF.CanBF(MaxDatBF.kSortAsOpaque); }
void SetSortAsOpaque(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kSortAsOpaque); }
bool GetSortAsOpaque() {return MaxDatBF.CanBF(MaxDatBF.kSortAsOpaque); }
void SetSortAsOpaque(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kSortAsOpaque); }
hsBool GetVS() {return MaxDatBF.CanBF(MaxDatBF.kVS); }
void SetVS(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kVS); }
bool GetVS() {return MaxDatBF.CanBF(MaxDatBF.kVS); }
void SetVS(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kVS); }
hsBool GetHasWaterHeight() { return MaxDatBF.CanBF(MaxDatBF.kWaterHeight); }
void SetHasWaterHeight(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterHeight); }
bool GetHasWaterHeight() { return MaxDatBF.CanBF(MaxDatBF.kWaterHeight); }
void SetHasWaterHeight(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kWaterHeight); }
float GetWaterHeight() { return fWaterHeight; }
void SetWaterHeight(float f) { SetHasWaterHeight(true); fWaterHeight = f; }
hsBool GetSmoothAll() {return MaxDatBF.CanBF(MaxDatBF.kSmoothAll); }
void SetSmoothAll(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kSmoothAll); }
bool GetSmoothAll() {return MaxDatBF.CanBF(MaxDatBF.kSmoothAll); }
void SetSmoothAll(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kSmoothAll); }
hsBool GetForceSortable() {return MaxDatBF.CanBF(MaxDatBF.kForceSortable); }
void SetForceSortable(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceSortable); }
bool GetForceSortable() {return MaxDatBF.CanBF(MaxDatBF.kForceSortable); }
void SetForceSortable(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceSortable); }
hsBool GetConcave() {return MaxDatBF.CanBF(MaxDatBF.kConcave); }
void SetConcave(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kConcave); }
bool GetConcave() {return MaxDatBF.CanBF(MaxDatBF.kConcave); }
void SetConcave(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kConcave); }
hsBool GetCalcEdgeLens() {return MaxDatBF.CanBF(MaxDatBF.kCalcEdgeLens); }
void SetCalcEdgeLens(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kCalcEdgeLens); }
bool GetCalcEdgeLens() {return MaxDatBF.CanBF(MaxDatBF.kCalcEdgeLens); }
void SetCalcEdgeLens(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kCalcEdgeLens); }
hsBool GetNoDeferDraw() {return MaxDatBF.CanBF(MaxDatBF.kNoDeferDraw); }
void SetNoDeferDraw(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoDeferDraw); }
bool GetNoDeferDraw() {return MaxDatBF.CanBF(MaxDatBF.kNoDeferDraw); }
void SetNoDeferDraw(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kNoDeferDraw); }
hsBool GetBlendToFB() {return MaxDatBF.CanBF(MaxDatBF.kBlendToFB); }
void SetBlendToFB(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kBlendToFB); }
bool GetBlendToFB() {return MaxDatBF.CanBF(MaxDatBF.kBlendToFB); }
void SetBlendToFB(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kBlendToFB); }
hsBool GetForceMaterialCopy() {return MaxDatBF.CanBF(MaxDatBF.kForceMatCopy); }
void SetForceMaterialCopy(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatCopy); }
bool GetForceMaterialCopy() {return MaxDatBF.CanBF(MaxDatBF.kForceMatCopy); }
void SetForceMaterialCopy(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kForceMatCopy); }
hsBool GetInstanced() {return MaxDatBF.CanBF(MaxDatBF.kIsInstanced); }
void SetInstanced(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsInstanced); }
bool GetInstanced() {return MaxDatBF.CanBF(MaxDatBF.kIsInstanced); }
void SetInstanced(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsInstanced); }
hsBool GetParticleRelated() {return MaxDatBF.CanBF(MaxDatBF.kParticleRelated); }
void SetParticleRelated(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kParticleRelated); }
bool GetParticleRelated() {return MaxDatBF.CanBF(MaxDatBF.kParticleRelated); }
void SetParticleRelated(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kParticleRelated); }
hsBool GetDup2Sided() {return MaxDatBF.CanBF(MaxDatBF.kDup2Sided); }
void SetDup2Sided(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kDup2Sided); }
bool GetDup2Sided() {return MaxDatBF.CanBF(MaxDatBF.kDup2Sided); }
void SetDup2Sided(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kDup2Sided); }
hsBool GetRadiateNorms() {return MaxDatBF.CanBF(MaxDatBF.kRadiateNorms); }
void SetRadiateNorms(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kRadiateNorms); }
bool GetRadiateNorms() {return MaxDatBF.CanBF(MaxDatBF.kRadiateNorms); }
void SetRadiateNorms(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kRadiateNorms); }
hsBool GetGeoDice() {return MaxDatBF.CanBF(MaxDatBF.kGeoDice); }
void SetGeoDice(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kGeoDice); }
bool GetGeoDice() {return MaxDatBF.CanBF(MaxDatBF.kGeoDice); }
void SetGeoDice(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kGeoDice); }
hsBool GetIsGUI() {return MaxDatBF.CanBF(MaxDatBF.kIsGUI); }
void SetIsGUI(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsGUI); }
bool GetIsGUI() {return MaxDatBF.CanBF(MaxDatBF.kIsGUI); }
void SetIsGUI(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kIsGUI); }
plSharedMesh* GetSwappableGeom() { return fSwapMesh;}
void SetSwappableGeom(plSharedMesh *sm) { fSwapMesh = sm; }
@ -387,22 +387,22 @@ public:
void AddBone(plMaxNodeBase* m) { fBones.Append(1, &m); }
void ClearBones() { fBones.ZeroCount(); }
hsBool HasFade() { return MaxDatBF.CanBF(MaxDatBF.kHasFade); }
bool HasFade() { return MaxDatBF.CanBF(MaxDatBF.kHasFade); }
void SetFade(const Box3& b) { MaxDatBF.SetBF((b.Min()[2] != 0)||(b.Max()[2] != 0), MaxDatBF.kHasFade); fFade = b; }
Box3 GetFade() { return fFade; }
hsBool HasLoadMask() { return MaxDatBF.CanBF(MaxDatBF.kHasLoadMask); }
bool HasLoadMask() { return MaxDatBF.CanBF(MaxDatBF.kHasLoadMask); }
plLoadMask GetLoadMask() { return HasLoadMask() ? fLoadMask : plLoadMask::kAlways; }
void AddLoadMask(const plLoadMask& m) { if( !HasLoadMask() ) { fLoadMask = m; MaxDatBF.SetBF(true, MaxDatBF.kHasLoadMask); }else{ fLoadMask |= m; } }
hsBool HasNormalChan() { return fNormalChan > 0; }
bool HasNormalChan() { return fNormalChan > 0; }
void SetNormalChan(int n) { fNormalChan = n; }
int GetNormalChan() { return fNormalChan; }
hsBool BlendLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kBLevelSet); }
bool BlendLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kBLevelSet); }
void SetBlendLevel(const plRenderLevel& l) { fBlendLevel = l; MaxDatBF.SetBF(true, MaxDatBF.kBLevelSet); }
const plRenderLevel& GetBlendLevel() { return fBlendLevel; }
hsBool OpaqueLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kOLevelSet); }
bool OpaqueLevelSet() { return MaxDatBF.CanBF(MaxDatBF.kOLevelSet); }
void SetOpaqueLevel(const plRenderLevel& l) { fOpaqueLevel = l; MaxDatBF.SetBF(true, MaxDatBF.kOLevelSet); }
const plRenderLevel& GetOpaqueLevel() { return fOpaqueLevel; }
@ -410,8 +410,8 @@ public:
hsTArray<int> *GetAlphaHackLayersCache( void ) { return fCachedAlphaHackLayerCounts; }
void SetAlphaHackLayersCache( hsTArray<int> *cache ) { fCachedAlphaHackLayerCounts = cache; }
hsBool GetOverrideHighLevelSDL() { return MaxDatBF.CanBF(MaxDatBF.kOverrideHighLevelSDL); }
void SetOverrideHighLevelSDL(hsBool b) { MaxDatBF.SetBF(b, MaxDatBF.kOverrideHighLevelSDL); }
bool GetOverrideHighLevelSDL() { return MaxDatBF.CanBF(MaxDatBF.kOverrideHighLevelSDL); }
void SetOverrideHighLevelSDL(bool b) { MaxDatBF.SetBF(b, MaxDatBF.kOverrideHighLevelSDL); }
uint8_t GetAnimCompress() { return fAnimCompression; }
void SetAnimCompress(uint8_t v) { fAnimCompression = v; }
float GetKeyReduceThreshold() { return fKeyReduceThreshold; }

8
Sources/Tools/MaxMain/plPhysXCooking.cpp
View File

@ -57,12 +57,12 @@ bool plPhysXCooking::fSkipErrors = false;
NxUtilLib* plPhysXCooking::fUtilLib =nil;
//assumes that the Vectors are normalized
hsBool ThreePlaneIntersect(const NxVec3& norm0, const NxVec3& point0,
bool ThreePlaneIntersect(const NxVec3& norm0, const NxVec3& point0,
const NxVec3& norm1, const NxVec3& point1,
const NxVec3& norm2, const NxVec3& point2, NxVec3& loc)
{
//need to make sure these planes aren't parallel
hsBool suc=0;
bool suc=0;
NxVec3 cross=norm1.cross( norm2);
float denom=norm0.dot(cross);
if(abs(denom)<0.0001) return 0;//basically paralell
@ -320,7 +320,7 @@ void ReadBoxFromHull(hsStream* stream, NxBoxShapeDesc& box)
// box.localPose.setRowMajor44(&mat.fMap[0][0]);
}
*/
hsBool ProjectPointOnToPlane(const hsVector3& planeNormal,float& d0,
bool ProjectPointOnToPlane(const hsVector3& planeNormal,float& d0,
const hsVector3 pointToProject, hsPoint3& res)
{
@ -376,7 +376,7 @@ void plPhysXCooking::PCA(const NxVec3* points,int numPoints, NxMat33& out)
}
hsVectorStream* plPhysXCooking::IMakePolytope(const plMaxMeshExtractor::NeutralMesh& inMesh)
{
hsBool success=0;
bool success=0;
std::vector<hsPoint3> outCloud;
hsPoint3 offset;
int numPlanes=26;

20
Sources/Tools/MaxMain/plPluginResManager.cpp
View File

@ -57,7 +57,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "plCommonObjLib.h"
#include "MaxComponent/plMiscComponents.h"
plKey plPluginResManager::NameToLoc(const char* age, const char* page, int32_t sequenceNumber, hsBool itinerant)
plKey plPluginResManager::NameToLoc(const char* age, const char* page, int32_t sequenceNumber, bool itinerant)
{
// Hack for now--always prefer paging out sceneNodes first
fPageOutHint = plSceneNode::Index();
@ -109,7 +109,7 @@ plKey plPluginResManager::NameToLoc(const char* age, const char* page, int32_t s
// seqNumber, returns the page for that combo (either by preloading it or
// by creating it).
plRegistryPageNode* plPluginResManager::INameToPage(const char* age, const char* page, int32_t sequenceNumber, hsBool itinerant)
plRegistryPageNode* plPluginResManager::INameToPage(const char* age, const char* page, int32_t sequenceNumber, bool itinerant)
{
// Find the location first, to see if it already exists
plRegistryPageNode* pageNode = FindPage(age, page);
@ -154,7 +154,7 @@ class plCommonKeyDistributor : public plRegistryKeyIterator
public:
plCommonKeyDistributor(plPluginResManager* mgr) : fMgr(mgr) {}
virtual hsBool EatKey(const plKey& key)
virtual bool EatKey(const plKey& key)
{
uint32_t count = plCommonObjLib::GetNumLibs();
@ -216,7 +216,7 @@ void plPluginResManager::IPreLoadTextures(plRegistryPageNode* pageNode, int32_t
class plEmptyIterator : public plRegistryKeyIterator
{
public:
virtual hsBool EatKey(const plKey& key) { return true; }
virtual bool EatKey(const plKey& key) { return true; }
} empty;
pageNode->IterateKeys(&empty);
@ -304,12 +304,12 @@ class plSeqNumberFinder : public plRegistryPageIterator
{
protected:
int32_t& fSeqNum;
hsBool fWillBeReserved;
bool fWillBeReserved;
public:
plSeqNumberFinder(int32_t& seqNum, hsBool willBeReserved) : fSeqNum(seqNum), fWillBeReserved(willBeReserved) {}
plSeqNumberFinder(int32_t& seqNum, bool willBeReserved) : fSeqNum(seqNum), fWillBeReserved(willBeReserved) {}
virtual hsBool EatPage(plRegistryPageNode* page)
virtual bool EatPage(plRegistryPageNode* page)
{
if (fSeqNum <= page->GetPageInfo().GetLocation().GetSequenceNumber() &&
fWillBeReserved == page->GetPageInfo().GetLocation().IsReserved())
@ -319,13 +319,13 @@ public:
};
plLocation plPluginResManager::ICreateLocation(const char* age, const char* page, hsBool itinerant)
plLocation plPluginResManager::ICreateLocation(const char* age, const char* page, bool itinerant)
{
int32_t seqNum = VerifySeqNumber(0, age, page);
return ICreateLocation(age, page, seqNum, itinerant);
}
plLocation plPluginResManager::ICreateLocation(const char* age, const char* page, int32_t seqNum, hsBool itinerant)
plLocation plPluginResManager::ICreateLocation(const char* age, const char* page, int32_t seqNum, bool itinerant)
{
bool willBeReserved = strcmpi(age, "global") == 0;
@ -381,7 +381,7 @@ class plWritePageIterator : public plRegistryPageIterator
{
public:
plWritePageIterator() {}
virtual hsBool EatPage(plRegistryPageNode *page)
virtual bool EatPage(plRegistryPageNode *page)
{
if (page->GetPageInfo().GetLocation() != plLocation::kGlobalFixedLoc)
page->Write();

8
Sources/Tools/MaxMain/plPluginResManager.h
View File

@ -60,7 +60,7 @@ public:
//------------------------
// Given a page string combo, returns the key of the sceneNode for that page. If the page does not exist, it creates one.
plKey NameToLoc(const char* age, const char* page, int32_t sequenceNumber, hsBool itinerant = false);
plKey NameToLoc(const char* age, const char* page, int32_t sequenceNumber, bool itinerant = false);
// Verifies that the given sequence number belongs to the given string combo and ONLY that combo. Returns a new, unique sequenceNumber if not
int32_t VerifySeqNumber(int32_t sequenceNumber, const char* age, const char* page);
@ -96,10 +96,10 @@ public:
void EndExport();
protected:
plLocation ICreateLocation(const char* age, const char* page, hsBool itinerant);
plLocation ICreateLocation(const char* age, const char* page, int32_t seqNum, hsBool itinerant);
plLocation ICreateLocation(const char* age, const char* page, bool itinerant);
plLocation ICreateLocation(const char* age, const char* page, int32_t seqNum, bool itinerant);
plRegistryPageNode* INameToPage(const char* age, const char* page, int32_t sequenceNumber, hsBool itinerant = false);
plRegistryPageNode* INameToPage(const char* age, const char* page, int32_t sequenceNumber, bool itinerant = false);
void IPreLoadTextures(plRegistryPageNode* pageNode, int32_t origSeqNumber);

2
Sources/Tools/MaxMain/plPythonMgr.cpp
View File

@ -444,7 +444,7 @@ bool plPythonMgr::IQueryPythonFile(char *fileName)
void plPythonMgr::IAddBool(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
hsBool def = false;
int def = 0;
IGetTupleInt(tuple, 3, def);
autoUI->AddCheckBox(id, nil, paramName, vid, vstates, def);