OU/CWE-ou-minkata
2
3
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-14 02:27:40 -04: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

10
Sources/Plasma/FeatureLib/pfPython/cyAnimation.cpp
View File

@ -116,12 +116,6 @@ void cyAnimation::SetAnimName(const char* name)
fAnimName = hsStrcpy(name);
}
void cyAnimation::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Play
@ -380,7 +374,7 @@ void cyAnimation::SkipToTime(float time)
//
// PURPOSE : Set whether the animation is to be looped or not
//
void cyAnimation::Looped(hsBool looped)
void cyAnimation::Looped(bool looped)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
@ -421,7 +415,7 @@ void cyAnimation::Looped(hsBool looped)
//
// PURPOSE : Sets the backwards state for the animation
//
void cyAnimation::Backwards(hsBool backwards)
void cyAnimation::Backwards(bool backwards)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )

8
Sources/Plasma/FeatureLib/pfPython/cyAnimation.h
View File

@ -58,7 +58,7 @@ class cyAnimation
plKey fSender;
hsTArray<plKey> fRecvr;
char* fAnimName;
hsBool fNetForce;
bool fNetForce;
virtual void IRunOneCmd(int cmd);
@ -90,7 +90,7 @@ public:
virtual PyObject* GetFirstRecvr();
virtual void SetNetForce(hsBool state);
virtual void SetNetForce(bool state) { fNetForce = state; }
// Play animation from start to end (whatever is already set)
//
@ -123,11 +123,11 @@ public:
// Set whether the animation is to be looped or not
//
virtual void Looped(hsBool looped);
virtual void Looped(bool looped);
// Sets the backwards state for the animation
//
virtual void Backwards(hsBool backwards);
virtual void Backwards(bool backwards);
// Sets the start and end of the looping points in the animation

54
Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
View File

@ -110,12 +110,6 @@ void cyAvatar::AddRecvr(plKey &recvr)
fRecvr.Append(recvr);
}
void cyAvatar::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
void cyAvatar::SetSenderKey(pyKey& pKey)
{
plKey k = pKey.getKey();
@ -174,8 +168,8 @@ plKey cyAvatar::IFindArmatureModKey(plKey avKey)
//
// PURPOSE : oneShot Avatar (must already be there)
//
void cyAvatar::OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
const plString &animName, hsBool drivable, hsBool reversible)
void cyAvatar::OneShot(pyKey &seekKey, float duration, bool usePhysics,
const plString &animName, bool drivable, bool reversible)
{
if ( fRecvr.Count() > 0 )
{
@ -218,7 +212,7 @@ void cyAvatar::OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
//
// PURPOSE : Run Behavior, could be single or multi-stage shot
//
void cyAvatar::RunBehavior(pyKey &behKey, hsBool netForce, hsBool netProp)
void cyAvatar::RunBehavior(pyKey &behKey, bool netForce, bool netProp)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
@ -314,7 +308,7 @@ void cyAvatar::RunBehavior(pyKey &behKey, hsBool netForce, hsBool netProp)
//
// PURPOSE : Run Behavior, multistage only, reply to specified key'd object
//
void cyAvatar::RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, hsBool netForce, hsBool netProp)
void cyAvatar::RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, bool netForce, bool netProp)
{
plMultistageBehMod* pMod = plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr());
if ( pMod )
@ -373,8 +367,8 @@ void cyAvatar::RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, hsBool netFor
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::NextStage(pyKey &behKey, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce)
void cyAvatar::NextStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
@ -388,7 +382,7 @@ void cyAvatar::NextStage(pyKey &behKey, float transTime, hsBool setTime, float n
// create the message
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg((plKey)fSender, avKey,
plAvBrainGenericMsg::kNextStage, 0, setTime, newTime,
setDirection, (bool)isForward, transTime);
setDirection, isForward, transTime);
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
@ -412,8 +406,8 @@ void cyAvatar::NextStage(pyKey &behKey, float transTime, hsBool setTime, float n
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::PreviousStage(pyKey &behKey, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce)
void cyAvatar::PreviousStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
@ -427,7 +421,7 @@ void cyAvatar::PreviousStage(pyKey &behKey, float transTime, hsBool setTime, flo
// create the message
plAvBrainGenericMsg* pMsg = new plAvBrainGenericMsg((plKey)fSender, avKey,
plAvBrainGenericMsg::kPrevStage, 0, setTime, newTime,
setDirection, (bool)isForward, transTime);
setDirection, isForward, transTime);
if ( netForce )
pMsg->SetBCastFlag(plMessage::kNetForce | plMessage::kNetPropagate);
@ -452,8 +446,8 @@ void cyAvatar::PreviousStage(pyKey &behKey, float transTime, hsBool setTime, flo
//
// NOTE: only works with multi-stage behaviors
//
void cyAvatar::GoToStage(pyKey &behKey, int32_t stage, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce)
void cyAvatar::GoToStage(pyKey &behKey, int32_t stage, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce)
{
// first there is someone to send to and make sure that we an avatar to send this to
if ( behKey.getKey() != nil && fRecvr.Count() > 0)
@ -480,7 +474,7 @@ void cyAvatar::GoToStage(pyKey &behKey, int32_t stage, float transTime, hsBool s
}
void cyAvatar::SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, hsBool netForce)
void cyAvatar::SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, bool netForce)
{
// if it is a Multistage guy
if ( plMultistageBehMod::ConvertNoRef(behKey.getKey()->GetObjectPtr()) != nil )
@ -508,7 +502,7 @@ void cyAvatar::SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, hsB
/* Unsupported. Ask Bob if you want it back.
void cyAvatar::Seek(pyKey &seekKey, float duration, hsBool usePhysics)
void cyAvatar::Seek(pyKey &seekKey, float duration, bool usePhysics)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
@ -1011,7 +1005,7 @@ PyObject* cyAvatar::GetMatchingClothingItem(const char* clothing_name)
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
hsBool cyAvatar::WearClothingItem(const char* clothing_name)
bool cyAvatar::WearClothingItem(const char* clothing_name)
{
return WearClothingItemU(clothing_name,true);
}
@ -1024,7 +1018,7 @@ hsBool cyAvatar::WearClothingItem(const char* clothing_name)
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns false, if clothing item was not found
//
hsBool cyAvatar::RemoveClothingItem(const char* clothing_name)
bool cyAvatar::RemoveClothingItem(const char* clothing_name)
{
return RemoveClothingItemU(clothing_name,true);
}
@ -1036,7 +1030,7 @@ hsBool cyAvatar::RemoveClothingItem(const char* clothing_name)
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
hsBool cyAvatar::TintClothingItem(const char* clothing_name, pyColor& tint)
bool cyAvatar::TintClothingItem(const char* clothing_name, pyColor& tint)
{
return TintClothingItemU(clothing_name,tint,true);
}
@ -1050,7 +1044,7 @@ hsBool cyAvatar::TintClothingItem(const char* clothing_name, pyColor& tint)
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
hsBool cyAvatar::TintClothingItemLayer(const char* clothing_name, pyColor& tint, uint8_t layer)
bool cyAvatar::TintClothingItemLayer(const char* clothing_name, pyColor& tint, uint8_t layer)
{
return TintClothingItemLayerU(clothing_name,tint,layer,true);
}
@ -1064,7 +1058,7 @@ hsBool cyAvatar::TintClothingItemLayer(const char* clothing_name, pyColor& tint,
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
hsBool cyAvatar::WearClothingItemU(const char* clothing_name, hsBool update)
bool cyAvatar::WearClothingItemU(const char* clothing_name, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
@ -1098,7 +1092,7 @@ hsBool cyAvatar::WearClothingItemU(const char* clothing_name, hsBool update)
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns false, if clothing item was not found
//
hsBool cyAvatar::RemoveClothingItemU(const char* clothing_name, hsBool update)
bool cyAvatar::RemoveClothingItemU(const char* clothing_name, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
@ -1132,7 +1126,7 @@ hsBool cyAvatar::RemoveClothingItemU(const char* clothing_name, hsBool update)
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
hsBool cyAvatar::TintClothingItemU(const char* clothing_name, pyColor& tint, hsBool update)
bool cyAvatar::TintClothingItemU(const char* clothing_name, pyColor& tint, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
@ -1165,7 +1159,7 @@ hsBool cyAvatar::TintClothingItemU(const char* clothing_name, pyColor& tint, hsB
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
hsBool cyAvatar::TintClothingItemLayerU(const char* clothing_name, pyColor& tint, uint8_t layer, hsBool update)
bool cyAvatar::TintClothingItemLayerU(const char* clothing_name, pyColor& tint, uint8_t layer, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
@ -1300,7 +1294,7 @@ void cyAvatar::TintSkin(pyColor& tint)
//
// PURPOSE : Tint the skin of the player's avatar with optional update flag
//
void cyAvatar::TintSkinU(pyColor& tint, hsBool update)
void cyAvatar::TintSkinU(pyColor& tint, bool update)
{
const plArmatureMod *avMod = nil;
// we can really only talk to one avatar, so just get the first one (which is probably the only one)
@ -1967,7 +1961,7 @@ bool IExitTopmostGenericMode()
//
// PURPOSE : Returns whether the top most brain is a human brain
//
hsBool cyAvatar::IsCurrentBrainHuman()
bool cyAvatar::IsCurrentBrainHuman()
{
plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar();
if (avatar)

48
Sources/Plasma/FeatureLib/pfPython/cyAvatar.h
View File

@ -67,7 +67,7 @@ class cyAvatar
protected:
plKey fSender;
hsTArray<plKey> fRecvr;
hsBool fNetForce;
bool fNetForce;
virtual const plArmatureMod* IFindArmatureMod(plKey avObj);
virtual plKey IFindArmatureModKey(plKey avObj);
@ -95,31 +95,31 @@ public:
// setters
void SetSender(plKey &sender);
void AddRecvr(plKey &recvr);
virtual void SetNetForce(hsBool state);
virtual void SetNetForce(bool state) { fNetForce = state; }
// oneShot Avatar (must already be there)
virtual void OneShot(pyKey &seekKey, float duration, hsBool usePhysics,
const plString &animName, hsBool drivable, hsBool reversible);
virtual void OneShot(pyKey &seekKey, float duration, bool usePhysics,
const plString &animName, bool drivable, bool reversible);
// oneShot Avatar
virtual void RunBehavior(pyKey &behKey, hsBool netForce, hsBool netProp);
virtual void RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, hsBool netForce, hsBool netProp);
virtual void RunBehavior(pyKey &behKey, bool netForce, bool netProp);
virtual void RunBehaviorAndReply(pyKey& behKey, pyKey& replyKey, bool netForce, bool netProp);
// for the multistage behaviors
virtual void NextStage(pyKey &behKey, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce);
virtual void PreviousStage(pyKey &behKey, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce);
virtual void GoToStage(pyKey &behKey, int32_t stage, float transTime, hsBool setTime, float newTime,
hsBool setDirection, bool isForward, hsBool netForce);
virtual void NextStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce);
virtual void PreviousStage(pyKey &behKey, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce);
virtual void GoToStage(pyKey &behKey, int32_t stage, float transTime, bool setTime, float newTime,
bool setDirection, bool isForward, bool netForce);
// static behavior functions:
static void SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, hsBool netForce);
static void SetLoopCount(pyKey &behKey, int32_t stage, int32_t loopCount, bool netForce);
virtual void SetSenderKey(pyKey &pKey);
// seek Avatar (must already be there)
//virtual void Seek(pyKey &seekKey, float duration, hsBool usePhysics);
//virtual void Seek(pyKey &seekKey, float duration, bool usePhysics);
/////////////////////////////////////////////////////////////////////////////
//
@ -214,7 +214,7 @@ public:
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
virtual hsBool WearClothingItem(const char* clothing_name);
virtual bool WearClothingItem(const char* clothing_name);
/////////////////////////////////////////////////////////////////////////////
//
@ -224,7 +224,7 @@ public:
// PURPOSE : Remove (take off) a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
virtual hsBool RemoveClothingItem(const char* clothing_name);
virtual bool RemoveClothingItem(const char* clothing_name);
/////////////////////////////////////////////////////////////////////////////
//
@ -233,7 +233,7 @@ public:
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
virtual hsBool TintClothingItem(const char* clothing_name, pyColor& tint);
virtual bool TintClothingItem(const char* clothing_name, pyColor& tint);
/////////////////////////////////////////////////////////////////////////////
//
@ -244,7 +244,7 @@ public:
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
virtual hsBool TintClothingItemLayer(const char* clothing_name, pyColor& tint, uint8_t layer);
virtual bool TintClothingItemLayer(const char* clothing_name, pyColor& tint, uint8_t layer);
/////////////////////////////////////////////////////////////////////////////
//
@ -254,7 +254,7 @@ public:
// PURPOSE : Wear a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
virtual hsBool WearClothingItemU(const char* clothing_name, hsBool update);
virtual bool WearClothingItemU(const char* clothing_name, bool update);
/////////////////////////////////////////////////////////////////////////////
//
@ -264,7 +264,7 @@ public:
// PURPOSE : Remove (take off) a particular piece of clothing based on name of clothing item
// : returns 0, if clothing item was not found
//
virtual hsBool RemoveClothingItemU(const char* clothing_name, hsBool update);
virtual bool RemoveClothingItemU(const char* clothing_name, bool update);
/////////////////////////////////////////////////////////////////////////////
//
@ -273,7 +273,7 @@ public:
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
virtual hsBool TintClothingItemU(const char* clothing_name, pyColor& tint, hsBool update);
virtual bool TintClothingItemU(const char* clothing_name, pyColor& tint, bool update);
/////////////////////////////////////////////////////////////////////////////
//
@ -284,7 +284,7 @@ public:
//
// PURPOSE : Tint a clothing item, i.e. change the color of it
//
virtual hsBool TintClothingItemLayerU(const char* clothing_name, pyColor& tint, uint8_t layer, hsBool update);
virtual bool TintClothingItemLayerU(const char* clothing_name, pyColor& tint, uint8_t layer, bool update);
/////////////////////////////////////////////////////////////////////////////
//
@ -328,7 +328,7 @@ public:
//
// PURPOSE : Tint the skin of the player's avatar with optional update flag
//
virtual void TintSkinU(pyColor& tint, hsBool update);
virtual void TintSkinU(pyColor& tint, bool update);
/////////////////////////////////////////////////////////////////////////////
//
@ -560,7 +560,7 @@ public:
//
void UnRegisterForBehaviorNotify(pyKey &selfKey);
static hsBool IsCurrentBrainHuman();
static bool IsCurrentBrainHuman();
};

33
Sources/Plasma/FeatureLib/pfPython/cyCamera.cpp
View File

@ -144,7 +144,7 @@ void cyCamera::Pop(pyKey& oldCamKey)
//
// PURPOSE : Send controlKey commands to the virtual camera (should be like a pass thru)
//
void cyCamera::ControlKey(int32_t controlKey, hsBool activated)
void cyCamera::ControlKey(int32_t controlKey, bool activated)
{
// make sure that we have a virtual camera to send this to
if ( fTheCam )
@ -174,7 +174,7 @@ void cyCamera::ControlKey(int32_t controlKey, hsBool activated)
//
// PURPOSE : Transition to a new camera (position and settings)
//
void cyCamera::TransitionTo(pyKey& newCamKey, double time, hsBool save)
void cyCamera::TransitionTo(pyKey& newCamKey, double time, bool save)
{
// create message
plCameraMsg* pMsg = new plCameraMsg;
@ -198,7 +198,7 @@ void cyCamera::TransitionTo(pyKey& newCamKey, double time, hsBool save)
}
}
void cyCamera::SetEnableFirstPersonOverride(hsBool state)
void cyCamera::SetEnableFirstPersonOverride(bool state) const
{
// must have a receiver!
if ( fTheCam )
@ -275,7 +275,7 @@ void cyCamera::SetFOV(float fov, double t)
}
void cyCamera::SetSmootherCam(hsBool state)
void cyCamera::SetSmootherCam(bool state)
{
if ( fTheCam )
{
@ -298,7 +298,7 @@ void cyCamera::SetSmootherCam(hsBool state)
}
}
hsBool cyCamera::IsSmootherCam()
bool cyCamera::IsSmootherCam()
{
if ( fTheCam )
{
@ -315,7 +315,7 @@ hsBool cyCamera::IsSmootherCam()
return false;
}
void cyCamera::SetWalkAndVerticalPan(hsBool state)
void cyCamera::SetWalkAndVerticalPan(bool state)
{
if ( fTheCam )
{
@ -332,7 +332,7 @@ void cyCamera::SetWalkAndVerticalPan(hsBool state)
}
hsBool cyCamera::IsWalkAndVerticalPan()
bool cyCamera::IsWalkAndVerticalPan()
{
if ( fTheCam )
{
@ -346,7 +346,7 @@ hsBool cyCamera::IsWalkAndVerticalPan()
}
void cyCamera::SetStayInFirstPerson(hsBool state)
void cyCamera::SetStayInFirstPerson(bool state)
{
if ( fTheCam )
{
@ -361,7 +361,7 @@ void cyCamera::SetStayInFirstPerson(hsBool state)
}
}
hsBool cyCamera::IsStayInFirstPerson()
bool cyCamera::IsStayInFirstPerson()
{
if ( fTheCam )
{
@ -373,18 +373,3 @@ hsBool cyCamera::IsStayInFirstPerson()
}
return false;
}
void cyCamera::SetAspectRatio(float aspectratio)
{
plVirtualCam1::SetAspectRatio(aspectratio);
}
float cyCamera::GetAspectRatio()
{
return plVirtualCam1::GetAspectRatio();
}
void cyCamera::RefreshFOV()
{
plVirtualCam1::SetFOV(plVirtualCam1::GetFOVw(), plVirtualCam1::GetFOVh());
}

29
Sources/Plasma/FeatureLib/pfPython/cyCamera.h
View File

@ -52,6 +52,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "HeadSpin.h"
#include "pyGlueHelpers.h"
#include "pnKeyedObject/plKey.h"
#include "pfCamera/plVirtualCamNeu.h"
class cyCamera
{
@ -80,7 +81,7 @@ public:
virtual void Pop(pyKey& oldCamKey);
// Send controlKey commands to the virtual camera (should be like a pass thru)
virtual void ControlKey(int32_t controlKey, hsBool activated);
virtual void ControlKey(int32_t controlKey, bool activated);
/////////////////////////////////////////////////////////////////////////////
@ -91,29 +92,29 @@ public:
//
// PURPOSE : Transition to a new camera (position and settings)
//
virtual void TransitionTo(pyKey& newCamKey, double time, hsBool save);
virtual void TransitionTo(pyKey& newCamKey, double time, bool save);
virtual void SetEnableFirstPersonOverride(hsBool state);
virtual void EnableFirstPersonOverride() { SetEnableFirstPersonOverride(true); }
virtual void DisableFirstPersonOverride() { SetEnableFirstPersonOverride(false); }
virtual void SetEnableFirstPersonOverride(bool state) const;
virtual void EnableFirstPersonOverride() const { SetEnableFirstPersonOverride(true); }
virtual void DisableFirstPersonOverride() const { SetEnableFirstPersonOverride(false); }
virtual void UndoFirstPerson();
virtual float GetFOV();
virtual void SetFOV(float fov, double t);
virtual void SetSmootherCam(hsBool state);
virtual hsBool IsSmootherCam();
virtual void SetSmootherCam(bool state);
virtual bool IsSmootherCam();
virtual void SetWalkAndVerticalPan(hsBool state);
virtual hsBool IsWalkAndVerticalPan();
virtual void SetWalkAndVerticalPan(bool state);
virtual bool IsWalkAndVerticalPan();
virtual void SetStayInFirstPerson(hsBool state);
virtual hsBool IsStayInFirstPerson();
virtual void SetStayInFirstPerson(bool state);
virtual bool IsStayInFirstPerson();
virtual void SetAspectRatio(float aspectratio);
virtual float GetAspectRatio();
virtual void RefreshFOV();
virtual void SetAspectRatio(float aspectratio) { plVirtualCam1::SetAspectRatio(aspectratio); }
virtual float GetAspectRatio() const { return plVirtualCam1::GetAspectRatio(); }
virtual void RefreshFOV() { plVirtualCam1::SetFOV(plVirtualCam1::GetFOVw(), plVirtualCam1::GetFOVh()); }
};

22
Sources/Plasma/FeatureLib/pfPython/cyDraw.cpp
View File

@ -66,15 +66,7 @@ void cyDraw::AddRecvr(plKey &recvr)
fRecvr.Append(recvr);
}
void cyDraw::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
void cyDraw::EnableT(hsBool state)
void cyDraw::EnableT(bool state)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
@ -82,7 +74,7 @@ void cyDraw::EnableT(hsBool state)
// create message
plEnableMsg* pMsg = new plEnableMsg;
// check if this needs to be network forced to all clients
if (fNetForce )
if (fNetForce)
{
// set the network propagate flag to make sure it gets to the other clients
pMsg->SetBCastFlag(plMessage::kNetPropagate);
@ -111,13 +103,3 @@ void cyDraw::EnableT(hsBool state)
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
void cyDraw::Enable()
{
EnableT(true);
}
void cyDraw::Disable()
{
EnableT(false);
}

10
Sources/Plasma/FeatureLib/pfPython/cyDraw.h
View File

@ -59,7 +59,7 @@ class cyDraw
protected:
plKey fSender;
hsTArray<plKey> fRecvr;
hsBool fNetForce;
bool fNetForce;
cyDraw(plKey sender=nil,const plKey recvr=nil);
public:
@ -74,12 +74,12 @@ public:
// setters
void SetSender(plKey &sender);
void AddRecvr(plKey &recvr);
virtual void SetNetForce(hsBool state);
void SetNetForce(bool state) { fNetForce = state; }
// Enable draw
virtual void EnableT(hsBool state);
virtual void Enable();
virtual void Disable();
virtual void EnableT(bool state);
virtual void Enable() { EnableT(true); }
virtual void Disable() { EnableT(false); }
};
#endif // cyDraw_h

30
Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
View File

@ -170,7 +170,7 @@ void cyMisc::Console(const char* command)
}
}
void cyMisc::ConsoleNet(const char* command, hsBool netForce)
void cyMisc::ConsoleNet(const char* command, bool netForce)
{
if ( command != nil )
{
@ -441,7 +441,7 @@ void cyMisc::DisableControlKeyEvents(pyKey &selfkey)
// PURPOSE : Return the net client (account) name of the player whose avatar
// key is provided.
//
hsBool cyMisc::WasLocallyNotified(pyKey &selfkey)
bool cyMisc::WasLocallyNotified(pyKey &selfkey)
{
return selfkey.WasLocalNotify();
}
@ -529,7 +529,7 @@ int cyMisc::GetLocalClientID()
return (plNetClientMgr::GetInstance()->GetPlayerID());
}
hsBool cyMisc::ValidateKey(pyKey& key)
bool cyMisc::ValidateKey(pyKey& key)
{
plKey pKey = key.getKey();
@ -844,7 +844,7 @@ void cyMisc::UnloadDialog(const char* name)
//
// PURPOSE : Test to see if a dialog is loaded (according to the dialog manager)
//
hsBool cyMisc::IsDialogLoaded(const char* name)
bool cyMisc::IsDialogLoaded(const char* name)
{
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
if ( mgr )
@ -1297,7 +1297,7 @@ void cyMisc::YesNoDialog(pyKey& sender, std::wstring thestring)
//
// RETURNS : nothing
//
void cyMisc::RateIt(const char* chronicleName, const char* thestring, hsBool onceFlag)
void cyMisc::RateIt(const char* chronicleName, const char* thestring, bool onceFlag)
{
// create the mesage to send
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kRateIt );
@ -1580,7 +1580,7 @@ void cyMisc::DisableAvatarCursorFade()
}
}
void cyMisc::FadeLocalPlayer(hsBool fade)
void cyMisc::FadeLocalPlayer(bool fade)
{
plNetClientMgr* nmgr = plNetClientMgr::GetInstance();
if (nmgr)
@ -1664,7 +1664,7 @@ void cyMisc::NotifyOffererPublicLinkAccepted(uint32_t offerer)
pMsg->Send();
}
void cyMisc::ToggleAvatarClickability(hsBool on)
void cyMisc::ToggleAvatarClickability(bool on)
{
plInputIfaceMgrMsg* pMsg = 0;
if (on)
@ -1704,7 +1704,7 @@ void cyMisc::SetShareAgeInstanceGuid(const Uuid& guid)
//
// PURPOSE : Returns current status of CCR dept
//
hsBool cyMisc::IsCCRAwayStatus()
bool cyMisc::IsCCRAwayStatus()
{
return !VaultGetCCRStatus();
}
@ -1716,7 +1716,7 @@ hsBool cyMisc::IsCCRAwayStatus()
//
// PURPOSE : Returns true if local player is a CCR
//
hsBool cyMisc::AmCCR()
bool cyMisc::AmCCR()
{
if ( plNetClientApp::GetInstance() )
return plNetClientApp::GetInstance()->AmCCR();
@ -1972,7 +1972,7 @@ void cyMisc::SetLightColorValue(pyKey& light, const plString& lightName, float r
}
#include "pnMessage/plEnableMsg.h"
void cyMisc::SetLightAnimationOn(pyKey& light, const plString& lightName, hsBool start)
void cyMisc::SetLightAnimationOn(pyKey& light, const plString& lightName, bool start)
{
// lightName is the name of the light object attached to the light that we want to talk to
// for the bug lights, this would be "RTOmni-BugLightTest"
@ -2045,7 +2045,7 @@ void cyMisc::SetLightAnimationOn(pyKey& light, const plString& lightName, hsBool
//
// PURPOSE : let you get control event messages at will (for pseudo-GUI's like the psnl bookshelf or clft imager)
void cyMisc::RegisterForControlEventMessages(hsBool on, pyKey& k)
void cyMisc::RegisterForControlEventMessages(bool on, pyKey& k)
{
plCmdIfaceModMsg* pMsg = new plCmdIfaceModMsg;
pMsg->SetSender(k.getKey());
@ -2549,7 +2549,7 @@ void cyMisc::FadeOut(float lenTime, bool holdFlag, bool noSound)
plgDispatch::MsgSend( msg );
}
void cyMisc::SetClickability(hsBool b)
void cyMisc::SetClickability(bool b)
{
plInputIfaceMgrMsg* msg = new plInputIfaceMgrMsg(b ? plInputIfaceMgrMsg::kEnableClickables : plInputIfaceMgrMsg::kDisableClickables );
plgDispatch::MsgSend(msg);
@ -2619,7 +2619,7 @@ void cyMisc::StartScreenCaptureWH(pyKey& selfkey, uint16_t width, uint16_t heigh
#include "plAvatar/plAvatarClothing.h"
void cyMisc::WearMaintainerSuit(pyKey& key, hsBool wear)
void cyMisc::WearMaintainerSuit(pyKey& key, bool wear)
{
// run on all machines, but only affects us if we call it on our local guy (who props it to others himself)
if (key.getKey() != plNetClientMgr::GetInstance()->GetLocalPlayerKey())
@ -2761,7 +2761,7 @@ PipelineParams *cyMisc::GetDefaultDisplayParams()
return fPipeline->GetDefaultParams();
}
void cyMisc::SetGraphicsOptions(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync)
void cyMisc::SetGraphicsOptions(int Width, int Height, int ColorDepth, bool Windowed, int NumAASamples, int MaxAnisotropicSamples, bool VSync)
{
// This has to send a message to plClient because python is loaded in the max plugins
@ -2813,7 +2813,7 @@ std::wstring cyMisc::GetInitPath()
return path;
}
void cyMisc::SetBehaviorNetFlags(pyKey & behKey, hsBool netForce, hsBool netProp)
void cyMisc::SetBehaviorNetFlags(pyKey & behKey, bool netForce, bool netProp)
{
if (plMultistageBehMod * behMod = plMultistageBehMod::ConvertNoRef(behKey.getKey()->ObjectIsLoaded()))
{

30
Sources/Plasma/FeatureLib/pfPython/cyMisc.h
View File

@ -133,7 +133,7 @@ public:
// optionally propagate over the net
//
static void Console(const char* command);
static void ConsoleNet(const char* command, hsBool netForce);
static void ConsoleNet(const char* command, bool netForce);
/////////////////////////////////////////////////////////////////////////////
//
@ -244,7 +244,7 @@ public:
// PURPOSE : Return the net client (account) name of the player whose avatar
// key is provided.
//
static hsBool WasLocallyNotified(pyKey &selfkey);
static bool WasLocallyNotified(pyKey &selfkey);
/////////////////////////////////////////////////////////////////////////////
//
@ -268,7 +268,7 @@ public:
static PyObject* GetAvatarKeyFromClientID(int clientID); // returns pyKey
static int GetLocalClientID();
static int GetClientIDFromAvatarKey(pyKey& avatar);
static hsBool ValidateKey(pyKey& key);
static bool ValidateKey(pyKey& key);
@ -378,7 +378,7 @@ public:
//
// PURPOSE : Test to see if a dialog is loaded (according to the dialog manager)
//
static hsBool IsDialogLoaded(const char* name);
static bool IsDialogLoaded(const char* name);
/////////////////////////////////////////////////////////////////////////////
//
@ -515,7 +515,7 @@ public:
//
// RETURNS : nothing
//
static void RateIt(const char* chronicleName, const char* thestring, hsBool onceFlag);
static void RateIt(const char* chronicleName, const char* thestring, bool onceFlag);
/////////////////////////////////////////////////////////////////////////////
//
@ -616,7 +616,7 @@ public:
//
static void EnableAvatarCursorFade();
static void DisableAvatarCursorFade();
static void FadeLocalPlayer(hsBool fade);
static void FadeLocalPlayer(bool fade);
/////////////////////////////////////////////////////////////////////////////
@ -631,7 +631,7 @@ public:
static void NotifyOffererPublicLinkAccepted(uint32_t offerer);
static void NotifyOffererPublicLinkRejected(uint32_t offerer);
static void NotifyOffererPublicLinkCompleted(uint32_t offerer);
static void ToggleAvatarClickability(hsBool on);
static void ToggleAvatarClickability(bool on);
static void SetShareSpawnPoint(const char* spawnPoint);
static void SetShareAgeInstanceGuid(const Uuid& guid);
@ -642,7 +642,7 @@ public:
//
// PURPOSE : Returns current status of CCR dept
//
static hsBool IsCCRAwayStatus();
static bool IsCCRAwayStatus();
//////////////////////////////////////////////////////////////////////////////
//
@ -651,7 +651,7 @@ public:
//
// PURPOSE : Returns true if local player is a CCR
//
static hsBool AmCCR();
static bool AmCCR();
//////////////////////////////////////////////////////////////////////////////
//
@ -709,7 +709,7 @@ public:
static void KillParticles(float time, float pct, pyKey& particles);
static int GetNumParticles(pyKey& host);
static void SetLightColorValue(pyKey& light, const plString& lightName, float r, float g, float b, float a);
static void SetLightAnimationOn(pyKey& light, const plString& lightName, hsBool start);
static void SetLightAnimationOn(pyKey& light, const plString& lightName, bool start);
//////////////////////////////////////////////////////////////////////////////
//
// Function : RegisterForControlEventMessages
@ -717,7 +717,7 @@ public:
//
// PURPOSE : let you get control event messages at will (for pseudo-GUI's like the psnl bookshelf or clft imager)
static void RegisterForControlEventMessages(hsBool on, pyKey& k);
static void RegisterForControlEventMessages(bool on, pyKey& k);
//////////////////////////////////////////////////////////////////////////////
//
@ -831,7 +831,7 @@ public:
//
// PURPOSE : globally enable or disable ALL clickables on this local client
//
static void SetClickability(hsBool b);
static void SetClickability(bool b);
//////////////////////////////////////////////////////////////////////////////
@ -876,7 +876,7 @@ public:
//
// PURPOSE : puts the maintainer suit on or off the avatar
//
static void WearMaintainerSuit(pyKey& key, hsBool wear);
static void WearMaintainerSuit(pyKey& key, bool wear);
static void WearDefaultClothing(pyKey& key);
static void WearDefaultClothingType(pyKey& key, uint32_t type);
@ -922,7 +922,7 @@ public:
static std::wstring GetLocalizedString(std::wstring name, const std::vector<std::wstring> & arguments);
static void EnablePlanarReflections(bool enable = true);
static void SetGraphicsOptions(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync);
static void SetGraphicsOptions(int Width, int Height, int ColorDepth, bool Windowed, int NumAASamples, int MaxAnisotropicSamples, bool VSync);
static void GetSupportedDisplayModes(std::vector<plDisplayMode> *res);
static int GetDesktopWidth();
static int GetDesktopHeight();
@ -937,7 +937,7 @@ public:
static std::wstring GetUserPath();
static std::wstring GetInitPath();
static void SetBehaviorNetFlags(pyKey & behKey, hsBool netForce, hsBool netProp);
static void SetBehaviorNetFlags(pyKey & behKey, bool netForce, bool netProp);
static void SendFriendInvite(const wchar_t email[], const wchar_t toName[]);
static PyObject* PyGuidGenerate();
static PyObject* GetAIAvatarsByModelName(const char* name);

6
Sources/Plasma/FeatureLib/pfPython/cyParticleSys.cpp
View File

@ -66,12 +66,6 @@ void cyParticleSys::AddRecvr(plKey &recvr)
fRecvr.Append(recvr);
}
void cyParticleSys::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : ISendParticleSysMsg

5
Sources/Plasma/FeatureLib/pfPython/cyParticleSys.h
View File

@ -58,7 +58,7 @@ class cyParticleSys
protected:
plKey fSender;
hsTArray<plKey> fRecvr;
hsBool fNetForce;
bool fNetForce;
void ISendParticleSysMsg(uint32_t param, float value);
@ -76,7 +76,7 @@ public:
// setters
void SetSender(plKey &sender);
void AddRecvr(plKey &recvr);
void SetNetForce(hsBool state);
void SetNetForce(bool state) { fNetForce = state; }
void SetParticlesPerSecond(float value);
void SetInitPitchRange(float value);
@ -90,7 +90,6 @@ public:
void SetGenLife(float value);
void SetPartLifeMin(float value);
void SetPartLifeMax(float value);
};

17
Sources/Plasma/FeatureLib/pfPython/cyPhysics.cpp
View File

@ -80,12 +80,6 @@ void cyPhysics::AddRecvr(plKey &recvr)
fRecvr.Append(recvr);
}
void cyPhysics::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
/////////////////////////////////////////////////////////////////////////////
//
// Function : Enable
@ -93,7 +87,7 @@ void cyPhysics::SetNetForce(hsBool state)
//
// PURPOSE : Enable physics (must already be there)
//
void cyPhysics::EnableT(hsBool state)
void cyPhysics::EnableT(bool state)
{
// must have a receiver!
if ( fRecvr.Count() > 0 )
@ -128,15 +122,6 @@ void cyPhysics::EnableT(hsBool state)
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
}
}
void cyPhysics::Enable()
{
EnableT(true);
}
void cyPhysics::Disable()
{
EnableT(false);
}
/////////////////////////////////////////////////////////////////////////////
//

10
Sources/Plasma/FeatureLib/pfPython/cyPhysics.h
View File

@ -62,7 +62,7 @@ class cyPhysics
protected:
plKey fSender;
hsTArray<plKey> fRecvr;
hsBool fNetForce;
bool fNetForce;
cyPhysics(plKey sender=nil,plKey recvr=nil);
@ -79,12 +79,12 @@ public:
void SetSender(plKey &sender);
void AddRecvr(plKey &recvr);
virtual void SetNetForce(hsBool state);
virtual void SetNetForce(bool state) { fNetForce = state; }
// Enable physics (must already be there)
virtual void EnableT(hsBool state);
virtual void Enable();
virtual void Disable();
virtual void EnableT(bool state);
virtual void Enable() { EnableT(true); }
virtual void Disable() { EnableT(false); }
virtual void EnableCollision();
virtual void DisableCollision();

16
Sources/Plasma/FeatureLib/pfPython/cyPythonInterface.cpp
View File

@ -178,8 +178,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "Games/VarSync/pyVarSyncGame.h"
int32_t PythonInterface::initialized = 0; // only need to initialize all of Python once
hsBool PythonInterface::FirstTimeInit = true; // start with "this is the first time"
hsBool PythonInterface::IsInShutdown = false; // whether we are _really_ in shutdown mode
bool PythonInterface::FirstTimeInit = true; // start with "this is the first time"
bool PythonInterface::IsInShutdown = false; // whether we are _really_ in shutdown mode
PyMethodDef* PythonInterface::plasmaMethods = nil; // the Plasma module's methods
PyObject* PythonInterface::plasmaMod = nil; // pointer to the Plasma module
@ -192,7 +192,7 @@ PyObject* PythonInterface::plasmaGameConstantsMod = nil; // python object that h
PyObject* PythonInterface::stdOut = nil; // python object of the stdout file
PyObject* PythonInterface::stdErr = nil; // python object of the err file
hsBool PythonInterface::debug_initialized = false; // has the debug been initialized yet?
bool PythonInterface::debug_initialized = false; // has the debug been initialized yet?
PyObject* PythonInterface::dbgMod = nil; // display module for stdout and stderr
PyObject* PythonInterface::dbgOut = nil;
PyObject* PythonInterface::dbgSlice = nil; // time slice function for the debug window
@ -1961,7 +1961,7 @@ PyObject* PythonInterface::FindModule(const char* module)
//
// Returns : True if unique , otherwise returns False
//
hsBool PythonInterface::IsModuleNameUnique(char* module)
bool PythonInterface::IsModuleNameUnique(char* module)
{
PyObject *m;
// first we must get rid of any old modules of the same name, we'll replace it
@ -2130,7 +2130,7 @@ PyObject* PythonInterface::CompileString(char *command, char* filename)
//
// PURPOSE : marshals an object into a char string
//
hsBool PythonInterface::DumpObject(PyObject* pyobj, char** pickle, int32_t* size)
bool PythonInterface::DumpObject(PyObject* pyobj, char** pickle, int32_t* size)
{
PyObject *s; // the python string object where the marsalled object wil go
// convert object to a marshalled string python object
@ -2180,7 +2180,7 @@ PyObject* PythonInterface::LoadObject(char* pickle, int32_t size)
//
// RETURNS : pointer to PyObject that is the result of the command
//
hsBool PythonInterface::RunStringInteractive(char *command, PyObject* module)
bool PythonInterface::RunStringInteractive(char *command, PyObject* module)
{
PyObject *d, *v;
// make sure that we're given a good module... or at least one with an address
@ -2216,7 +2216,7 @@ hsBool PythonInterface::RunStringInteractive(char *command, PyObject* module)
//
// PURPOSE : run a python string in a specific module name
//
hsBool PythonInterface::RunString(char *command, PyObject* module)
bool PythonInterface::RunString(char *command, PyObject* module)
{
PyObject *d, *v;
// make sure that we're given a good module... or at least one with an address
@ -2252,7 +2252,7 @@ hsBool PythonInterface::RunString(char *command, PyObject* module)
//
// PURPOSE : run a compiled python code in a specific module name
//
hsBool PythonInterface::RunPYC(PyObject* code, PyObject* module)
bool PythonInterface::RunPYC(PyObject* code, PyObject* module)
{
PyObject *d, *v;
// make sure that we're given a good module... or at least one with an address

16
Sources/Plasma/FeatureLib/pfPython/cyPythonInterface.h
View File

@ -63,8 +63,8 @@ class PythonInterface
private:
static int32_t initialized; // count how many times we initialize
// and make sure that many finalize on the way out
static hsBool FirstTimeInit;
static hsBool IsInShutdown; // whether we are _really_ in shutdown mode
static bool FirstTimeInit;
static bool IsInShutdown; // whether we are _really_ in shutdown mode
static PyMethodDef* plasmaMethods;
static PyObject* plasmaMod; // python object that holds the Plasma module
@ -77,7 +77,7 @@ private:
static PyObject* stdOut; // python object of the stdout file
static PyObject* stdErr; // python object of the err file
static hsBool debug_initialized; // has the debug been initialized yet?
static bool debug_initialized; // has the debug been initialized yet?
static PyObject* dbgMod; // display module for stdout and stderr
static PyObject* dbgOut;
static PyObject* dbgSlice; // time slice function for the debug window
@ -150,7 +150,7 @@ public:
static PyObject* GetPlasmaItem(char* item);
// Determine if the module name is unique
static hsBool IsModuleNameUnique(char* module);
static bool IsModuleNameUnique(char* module);
// get an item (probably a function) from a specific module
static PyObject* GetModuleItem(char* item, PyObject* module);
@ -174,7 +174,7 @@ public:
//
// PURPOSE : marshals an object into a char string
//
static hsBool DumpObject(PyObject* pyobj, char** pickle, int32_t* size);
static bool DumpObject(PyObject* pyobj, char** pickle, int32_t* size);
/////////////////////////////////////////////////////////////////////////////
//
@ -196,7 +196,7 @@ public:
// PURPOSE : run a python string in a specific module name
// : Interactive mode (displays results)
//
static hsBool RunStringInteractive(char *command, PyObject* module);
static bool RunStringInteractive(char *command, PyObject* module);
/////////////////////////////////////////////////////////////////////////////
@ -207,7 +207,7 @@ public:
//
// PURPOSE : run a python string in a specific module name
//
static hsBool RunString(char *command, PyObject* module);
static bool RunString(char *command, PyObject* module);
/////////////////////////////////////////////////////////////////////////////
@ -218,7 +218,7 @@ public:
//
// PURPOSE : run a compiled python code in a specific module name
//
static hsBool RunPYC(PyObject* code, PyObject* module);
static bool RunPYC(PyObject* code, PyObject* module);
/////////////////////////////////////////////////////////////////////////////
//

8
Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
View File

@ -325,7 +325,7 @@ class pfPythonKeyCatcher : public plDefaultKeyCatcher
}
};
hsBool plPythonFileMod::fAtConvertTime = false;
bool plPythonFileMod::fAtConvertTime = false;
/////////////////////////////////////////////////////////////////////////////
//
@ -441,7 +441,7 @@ bool plPythonFileMod::ILoadPythonCode()
char pathandfile[256];
sprintf(pathandfile, ".\\python\\%s.py",fPythonFile);
wchar_t *wPathandfile = hsStringToWString(pathandfile);
hsBool exists = PathDoesFileExist(wPathandfile);
bool exists = PathDoesFileExist(wPathandfile);
delete [] wPathandfile;
if (exists)
{
@ -1163,7 +1163,7 @@ void plPythonFileMod::IFindActivatorAndAdd(const plString &activatorName, int32_
// Tasks:
// - Call the Python code's Update function (if there)
//
hsBool plPythonFileMod::IEval(double secs, float del, uint32_t dirty)
bool plPythonFileMod::IEval(double secs, float del, uint32_t dirty)
{
if ( fModule )
{
@ -1231,7 +1231,7 @@ hsBool plPythonFileMod::IEval(double secs, float del, uint32_t dirty)
//
// PURPOSE : Handle all the different types of messages that we recv
//
hsBool plPythonFileMod::MsgReceive(plMessage* msg)
bool plPythonFileMod::MsgReceive(plMessage* msg)
{
// is it a ref message
plGenRefMsg* genRefMsg = plGenRefMsg::ConvertNoRef(msg);

16
Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.h
View File

@ -69,7 +69,7 @@ protected:
plPythonSDLModifier* fSDLMod;
hsBool IEval(double secs, float del, uint32_t dirty);
bool IEval(double secs, float del, uint32_t dirty);
plString IMakeModuleName(plSceneObject* sobj);
@ -88,12 +88,12 @@ protected:
// internal data
PyObject* fModule; // python module object
PyObject* fInstance; // python object that the instance of the class to run
static hsBool fAtConvertTime; // flag for when in convert time within Max, don't run code
hsBool fLocalNotify; // True when This Mod was Notified by a local plNotify
hsBool fIsFirstTimeEval; // flag to determine when the first time at the eval,
static bool fAtConvertTime; // flag for when in convert time within Max, don't run code
bool fLocalNotify; // True when This Mod was Notified by a local plNotify
bool fIsFirstTimeEval; // flag to determine when the first time at the eval,
// so the Python coders can hava a chance to run initialization
// code after the system is up, but before things are displayed
hsBool fAmIAttachedToClone; // is this python file mod attached to a cloned object
bool fAmIAttachedToClone; // is this python file mod attached to a cloned object
// callback class for the KI
PythonVaultCallback *fVaultCallback;
@ -129,14 +129,14 @@ public:
GETINTERFACE_ANY( plPythonFileMod, plMultiModifier );
plPythonSDLModifier* GetSDLMod() { return fSDLMod; }
hsBool WasLocalNotify() { return fLocalNotify; }
bool WasLocalNotify() { return fLocalNotify; }
plPipeline* GetPipeline() { return fPipe; }
virtual void SetSourceFile(const char* filename);
virtual int getPythonOutput(std::string* line);
virtual void ReportError();
virtual void DisplayPythonOutput();
static void SetAtConvertTime() { fAtConvertTime=true; }
virtual hsBool AmIAttachedToClone() { return fAmIAttachedToClone; }
virtual bool AmIAttachedToClone() { return fAmIAttachedToClone; }
virtual void AddToNotifyList(plKey pKey) { fReceivers.Append(pKey); }
virtual int32_t NotifyListCount() { return fReceivers.Count(); }
@ -152,7 +152,7 @@ public:
virtual void EnableControlKeyEvents();
virtual void DisableControlKeyEvents();
virtual hsBool MsgReceive(plMessage* msg);
virtual bool MsgReceive(plMessage* msg);
virtual void Read(hsStream* stream, hsResMgr* mgr);
virtual void Write(hsStream* stream, hsResMgr* mgr);

6
Sources/Plasma/FeatureLib/pfPython/plPythonPack.cpp
View File

@ -86,7 +86,7 @@ public:
void Close();
PyObject* OpenPacked(const char *fileName);
hsBool IsPackedFile(const char* fileName);
bool IsPackedFile(const char* fileName);
};
PyObject* PythonPack::OpenPythonPacked(const char* fileName)
@ -94,7 +94,7 @@ PyObject* PythonPack::OpenPythonPacked(const char* fileName)
return plPythonPack::Instance().OpenPacked(fileName);
}
hsBool PythonPack::IsItPythonPacked(const char* fileName)
bool PythonPack::IsItPythonPacked(const char* fileName)
{
return plPythonPack::Instance().IsPackedFile(fileName);
}
@ -234,7 +234,7 @@ PyObject* plPythonPack::OpenPacked(const char* fileName)
return nil;
}
hsBool plPythonPack::IsPackedFile(const char* fileName)
bool plPythonPack::IsPackedFile(const char* fileName)
{
if (!Open())
return nil;

2
Sources/Plasma/FeatureLib/pfPython/plPythonPack.h
View File

@ -47,7 +47,7 @@ typedef struct _object PyObject;
namespace PythonPack
{
PyObject* OpenPythonPacked(const char* fileName);
hsBool IsItPythonPacked(const char* fileName);
bool IsItPythonPacked(const char* fileName);
}
#endif // plPythonPack_h_inc

6
Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h
View File

@ -99,7 +99,7 @@ public:
float fFloatNumber;
hsBool fBool;
bool fBool;
} datarecord;
@ -229,7 +229,7 @@ public:
fValueType = kFloat;
datarecord.fFloatNumber = number;
}
void SetTobool(hsBool state)
void SetTobool(bool state)
{
SetToNone();
fValueType = kbool;
@ -241,7 +241,7 @@ public:
fValueType = kString;
fString = string;
}
void SetToSceneObject(plKey key, hsBool list=false)
void SetToSceneObject(plKey key, bool list=false)
{
SetToNone();
if (list)

4
Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.cpp
View File

@ -185,7 +185,7 @@ void plPythonSDLModifier::SetDefault(const char* key, PyObject* value)
ISetItem(key, value);
}
void plPythonSDLModifier::SetItemIdx(const char* key, int idx, PyObject* value, hsBool sendImmediate)
void plPythonSDLModifier::SetItemIdx(const char* key, int idx, PyObject* value, bool sendImmediate)
{
if (!value)
{
@ -338,7 +338,7 @@ void plPythonSDLModifier::IPutCurrentStateIn(plStateDataRecord* dstState)
}
}
void plPythonSDLModifier::IDirtySynchState(const char* name, hsBool sendImmediate)
void plPythonSDLModifier::IDirtySynchState(const char* name, bool sendImmediate)
{
SDLMap::iterator it = fMap.find(name);
if (it != fMap.end())

4
Sources/Plasma/FeatureLib/pfPython/plPythonSDLModifier.h
View File

@ -87,7 +87,7 @@ protected:
bool IPythonVarIdxToSDL(plSimpleStateVariable* var, int varIdx, int type, PyObject* pyVar, const char* hintstring);
void ISetItem(const char* key, PyObject* value);
void IDirtySynchState(const char* name, hsBool sendImmediate = false);
void IDirtySynchState(const char* name, bool sendImmediate = false);
void IPutCurrentStateIn(plStateDataRecord* dstState);
void ISetCurrentStateFrom(const plStateDataRecord* srcState);
@ -112,7 +112,7 @@ public:
PyObject* GetItem(const char* key);
void SetItem(const char* key, PyObject* value);
void SetItemIdx(const char* key, int idx, PyObject* value, hsBool sendImmediate = false);
void SetItemIdx(const char* key, int idx, PyObject* value, bool sendImmediate = false);
void SetFlags(const char* name, bool sendImmediate, bool skipOwnershipCheck);
void SetTagString(const char* name, const char* tag);
};

36
Sources/Plasma/FeatureLib/pfPython/pyAudioControl.cpp
View File

@ -194,14 +194,14 @@ void pyAudioControl::Disable()
plgAudioSys::Activate(false);
}
hsBool pyAudioControl::IsEnabled()
bool pyAudioControl::IsEnabled()
{
return plgAudioSys::Active();
}
// Enable or disable load-on-demand for sounds
void pyAudioControl::SetLoadOnDemand( hsBool state )
void pyAudioControl::SetLoadOnDemand( bool state )
{
plSound::SetLoadOnDemand(state);
}
@ -209,7 +209,7 @@ void pyAudioControl::SetLoadOnDemand( hsBool state )
// Enables or disables two-stage LOD, where sounds can be loaded into RAM but not into sound buffers.
// ...Less of a performance hit, harder on memory.
void pyAudioControl::SetTwoStageLOD( hsBool state )
void pyAudioControl::SetTwoStageLOD( bool state )
{
// For two-stage LOD, we want to disable LoadFromDiskOnDemand, so that we'll load into RAM at startup but not
// into sound buffers until demanded to do so. Enabling LoadFromDiskOnDemand basically conserves as much memory
@ -219,24 +219,24 @@ void pyAudioControl::SetTwoStageLOD( hsBool state )
// Enable audio hardware acceleration
void pyAudioControl::UseHardwareAcceleration( hsBool state )
void pyAudioControl::UseHardwareAcceleration( bool state )
{
plgAudioSys::SetUseHardware(state);
}
hsBool pyAudioControl::IsHardwareAccelerated()
bool pyAudioControl::IsHardwareAccelerated()
{
return plgAudioSys::Hardware();
}
// Enable EAX sound acceleration (requires hardware acceleration)
void pyAudioControl::UseEAXAcceleration( hsBool state )
void pyAudioControl::UseEAXAcceleration( bool state )
{
plgAudioSys::EnableEAX(state);
}
hsBool pyAudioControl::IsUsingEAXAcceleration()
bool pyAudioControl::IsUsingEAXAcceleration()
{
return plgAudioSys::UsingEAX();
}
@ -253,12 +253,12 @@ void pyAudioControl::UnmuteAll()
plgAudioSys::SetMuted(false);
}
hsBool pyAudioControl::IsMuted()
bool pyAudioControl::IsMuted()
{
return plgAudioSys::IsMuted();
}
hsBool pyAudioControl::SupportEAX(const char *deviceName)
bool pyAudioControl::SupportEAX(const char *deviceName)
{
return plgAudioSys::SupportsEAX(deviceName);
}
@ -268,7 +268,7 @@ hsBool pyAudioControl::SupportEAX(const char *deviceName)
// Voice Settings
// Sets the microphone volume, in the range of 0 to 1
hsBool pyAudioControl::CanSetMicLevel()
bool pyAudioControl::CanSetMicLevel()
{
return plWinMicLevel::CanSetLevel();
}
@ -291,41 +291,41 @@ float pyAudioControl::GetMicLevel()
// turn voice recording on or off
void pyAudioControl::EnableVoiceRecording( hsBool state )
void pyAudioControl::EnableVoiceRecording( bool state )
{
plVoiceRecorder::EnableRecording(state);
}
hsBool pyAudioControl::IsVoiceRecordingEnabled()
bool pyAudioControl::IsVoiceRecordingEnabled()
{
return plVoiceRecorder::RecordingEnabled();
}
// turn voice compression on and off
void pyAudioControl::EnableVoiceCompression( hsBool state )
void pyAudioControl::EnableVoiceCompression( bool state )
{
}
hsBool pyAudioControl::IsVoiceCompressionEnabled()
bool pyAudioControl::IsVoiceCompressionEnabled()
{
return true;
}
// turn voice-over-net on and off
void pyAudioControl::EnableVoiceNetBroadcast( hsBool state )
void pyAudioControl::EnableVoiceNetBroadcast( bool state )
{
//plWinRecorder::EnableNetVoice(state);
}
hsBool pyAudioControl::IsVoiceNetBroadcastEnabled()
bool pyAudioControl::IsVoiceNetBroadcastEnabled()
{
return true;
}
void pyAudioControl::EnableVoiceChat(hsBool enable)
void pyAudioControl::EnableVoiceChat(bool enable)
{
plVoicePlayer::Enable(enable);
}
@ -344,7 +344,7 @@ void pyAudioControl::HideIcons()
// turn push-to-talk on or off
void pyAudioControl::PushToTalk( hsBool state )
void pyAudioControl::PushToTalk( bool state )
{
plVoiceRecorder::EnablePushToTalk(state);
}

36
Sources/Plasma/FeatureLib/pfPython/pyAudioControl.h
View File

@ -85,27 +85,27 @@ public:
// Switch DirectX Audio on or off at runtime
virtual void Enable();
virtual void Disable();
virtual hsBool IsEnabled();
virtual bool IsEnabled();
// Enable or disable load-on-demand for sounds
virtual void SetLoadOnDemand( hsBool state );
virtual void SetLoadOnDemand( bool state );
// Enables or disables two-stage LOD, where sounds can be loaded into RAM but not into sound buffers.
// ...Less of a performance hit, harder on memory.
virtual void SetTwoStageLOD( hsBool state );
virtual void SetTwoStageLOD( bool state );
// Enable audio hardware acceleration
virtual void UseHardwareAcceleration( hsBool state );
virtual hsBool IsHardwareAccelerated();
virtual void UseHardwareAcceleration( bool state );
virtual bool IsHardwareAccelerated();
// Enable EAX sound acceleration (requires hardware acceleration)
virtual void UseEAXAcceleration( hsBool state );
virtual hsBool IsUsingEAXAcceleration();
virtual void UseEAXAcceleration( bool state );
virtual bool IsUsingEAXAcceleration();
// Mute or unmute all sounds
virtual void MuteAll();
virtual void UnmuteAll();
virtual hsBool IsMuted();
virtual bool IsMuted();
virtual void SetAudioSystemMode(int mode); // sets the current mode
virtual int GetAudioSystemMode(); // returns the current mode
@ -121,30 +121,30 @@ public:
// Voice Settings
// Sets the microphone volume, in the range of 0 to 1
virtual hsBool CanSetMicLevel();
virtual bool CanSetMicLevel();
virtual void SetMicLevel( float level );
virtual float GetMicLevel();
// turn voice recording on or off
virtual void EnableVoiceRecording( hsBool state );
virtual hsBool IsVoiceRecordingEnabled();
virtual void EnableVoiceRecording( bool state );
virtual bool IsVoiceRecordingEnabled();
// turn voice compression on and off
virtual void EnableVoiceCompression( hsBool state );
virtual hsBool IsVoiceCompressionEnabled();
virtual void EnableVoiceCompression( bool state );
virtual bool IsVoiceCompressionEnabled();
// turn voice-over-net on and off
virtual void EnableVoiceNetBroadcast( hsBool state );
virtual hsBool IsVoiceNetBroadcastEnabled();
virtual void EnableVoiceNetBroadcast( bool state );
virtual bool IsVoiceNetBroadcastEnabled();
void EnableVoiceChat(hsBool enable);
void EnableVoiceChat(bool enable);
// turn voice recording icons on and off
virtual void ShowIcons();
virtual void HideIcons();
// turn push-to-talk on or off
virtual void PushToTalk( hsBool state );
virtual void PushToTalk( bool state );
// Set the squelch level
virtual void SquelchLevel( float level );
@ -159,7 +159,7 @@ public:
virtual void SetPriorityCutoff( uint8_t cut );
// does the device specified support EAX
virtual hsBool SupportEAX(const char *deviceName);
virtual bool SupportEAX(const char *deviceName);
};

4
Sources/Plasma/FeatureLib/pfPython/pyColor.h
View File

@ -89,11 +89,11 @@ public:
void setAlpha(float alpha) { fColor.a = alpha; }
// override the equals to operator
hsBool operator==(const pyColor &color) const
bool operator==(const pyColor &color) const
{
return ((pyColor*)this)->getColor() == ((pyColor&)color).getColor();
}
hsBool operator!=(const pyColor &color) const { return !(color == *this); }
bool operator!=(const pyColor &color) const { return !(color == *this); }
// helper colors settings
void White() { fColor.Set(1.0,1.0,1.0,1.0); }

10
Sources/Plasma/FeatureLib/pfPython/pyDrawControl.cpp
View File

@ -106,7 +106,7 @@ void pyDrawControl::DisableShadows()
plShadowCaster::DisableShadowCast();
#endif
}
hsBool pyDrawControl::IsShadowsEnabled()
bool pyDrawControl::IsShadowsEnabled()
{
#ifndef BUILDING_PYPLASMA
return !plShadowCaster::ShadowCastDisabled();
@ -115,7 +115,7 @@ hsBool pyDrawControl::IsShadowsEnabled()
#endif
}
hsBool pyDrawControl::CanShadowCast()
bool pyDrawControl::CanShadowCast()
{
#ifndef BUILDING_PYPLASMA
return plShadowCaster::CanShadowCast();
@ -158,7 +158,7 @@ void pyDrawControl::SetMouseUninverted()
#endif
}
hsBool pyDrawControl::IsMouseInverted()
bool pyDrawControl::IsMouseInverted()
{
#ifndef BUILDING_PYPLASMA
return plMouseDevice::GetInverted();
@ -167,14 +167,14 @@ hsBool pyDrawControl::IsMouseInverted()
#endif
}
void pyDrawControl::SetClickToTurn(hsBool state)
void pyDrawControl::SetClickToTurn(bool state)
{
#ifndef BUILDING_PYPLASMA
plArmatureMod::fClickToTurn = state;
#endif
}
hsBool pyDrawControl::IsClickToTurn()
bool pyDrawControl::IsClickToTurn()
{
#ifndef BUILDING_PYPLASMA
if (plArmatureMod::fClickToTurn)

10
Sources/Plasma/FeatureLib/pfPython/pyDrawControl.h
View File

@ -67,18 +67,18 @@ public:
static float GetShadowVisDistance();
static void EnableShadows();
static void DisableShadows();
static hsBool IsShadowsEnabled();
static hsBool CanShadowCast();
static bool IsShadowsEnabled();
static bool CanShadowCast();
static void DisableRenderScene();
static void EnableRenderScene();
static void SetMouseInverted();
static void SetMouseUninverted();
static hsBool IsMouseInverted();
static bool IsMouseInverted();
static void SetClickToTurn(hsBool state);
static hsBool IsClickToTurn();
static void SetClickToTurn(bool state);
static bool IsClickToTurn();
};
#endif // _pyDrawControl_h_

8
Sources/Plasma/FeatureLib/pfPython/pyDynamicText.cpp
View File

@ -103,12 +103,12 @@ void pyDynamicText::AddReceiver(pyKey& key)
}
void pyDynamicText::SetNetPropagate(hsBool propagate)
void pyDynamicText::SetNetPropagate(bool propagate)
{
fNetPropagate = propagate;
}
void pyDynamicText::SetNetForce(hsBool force)
void pyDynamicText::SetNetForce(bool force)
{
fNetForce = force;
}
@ -311,7 +311,7 @@ void pyDynamicText::DrawTextW( int16_t x, int16_t y, std::wstring text )
//
// Draw an image on the DynamicMap
//
void pyDynamicText::DrawImage( uint16_t x, uint16_t y, pyImage& image, hsBool respectAlpha )
void pyDynamicText::DrawImage( uint16_t x, uint16_t y, pyImage& image, bool respectAlpha )
{
// create message
plDynamicTextMsg* pMsg = ICreateDTMsg();
@ -327,7 +327,7 @@ void pyDynamicText::DrawImage( uint16_t x, uint16_t y, pyImage& image, hsBool re
// Draw an image on the DynamicMap
//
void pyDynamicText::DrawImageClipped( uint16_t x, uint16_t y, pyImage& image, uint16_t cx, uint16_t cy, uint16_t cw, uint16_t ch,
hsBool respectAlpha )
bool respectAlpha )
{
// create message
plDynamicTextMsg* pMsg = ICreateDTMsg();

16
Sources/Plasma/FeatureLib/pfPython/pyDynamicText.h
View File

@ -64,18 +64,18 @@ private:
// the list of receivers that want to be notified
hsTArray<plKey> fReceivers;
hsBool fNetPropagate;
hsBool fNetForce;
bool fNetPropagate;
bool fNetForce;
// clipping
hsBool fClip;
bool fClip;
uint16_t fClipLeft;
uint16_t fClipTop;
uint16_t fClipRight;
uint16_t fClipBottom;
// wrapping
hsBool fWrap;
bool fWrap;
uint16_t fWrapWidth;
uint16_t fWrapHeight;
@ -104,8 +104,8 @@ public:
virtual void SetSender(pyKey& selfKey);
virtual void ClearReceivers();
virtual void AddReceiver(pyKey& key);
virtual void SetNetPropagate(hsBool propagate);
virtual void SetNetForce(hsBool force);
virtual void SetNetPropagate(bool propagate);
virtual void SetNetForce(bool force);
// dynamicText commands
virtual void ClearToColor( pyColor& color );
@ -121,9 +121,9 @@ public:
virtual void UnsetWrapping();
virtual void DrawText( int16_t x, int16_t y, const char *text );
virtual void DrawTextW( int16_t x, int16_t y, std::wstring text );
virtual void DrawImage( uint16_t x, uint16_t y, pyImage& image, hsBool respectAlpha );
virtual void DrawImage( uint16_t x, uint16_t y, pyImage& image, bool respectAlpha );
virtual void DrawImageClipped( uint16_t x, uint16_t y, pyImage& image, uint16_t cx, uint16_t cy, uint16_t cw, uint16_t ch,
hsBool respectAlpha );
bool respectAlpha );
virtual void PurgeImage( void );
// Actually return the visible width and height, since that's what you want to be drawing to

18
Sources/Plasma/FeatureLib/pfPython/pyGUIControl.cpp
View File

@ -81,7 +81,7 @@ pyGUIControl& pyGUIControl::Copy(const pyGUIControl& other)
}
// override the equals to operator
hsBool pyGUIControl::operator==(const pyGUIControl &gcobj) const
bool pyGUIControl::operator==(const pyGUIControl &gcobj) const
{
plKey theirs = ((pyGUIControl&)gcobj).getObjKey();
if ( fGCkey == nil && theirs == nil )
@ -121,7 +121,7 @@ uint32_t pyGUIControl::GetTagID()
}
void pyGUIControl::SetEnabled( hsBool e )
void pyGUIControl::SetEnabled( bool e )
{
if ( fGCkey )
{
@ -138,7 +138,7 @@ void pyGUIControl::SetEnabled( hsBool e )
}
}
hsBool pyGUIControl::IsEnabled( void )
bool pyGUIControl::IsEnabled( void )
{
if ( fGCkey )
{
@ -150,7 +150,7 @@ hsBool pyGUIControl::IsEnabled( void )
return false;
}
void pyGUIControl::SetFocused( hsBool e )
void pyGUIControl::SetFocused( bool e )
{
if ( fGCkey )
{
@ -161,7 +161,7 @@ void pyGUIControl::SetFocused( hsBool e )
}
}
hsBool pyGUIControl::IsFocused( void )
bool pyGUIControl::IsFocused( void )
{
if ( fGCkey )
{
@ -173,7 +173,7 @@ hsBool pyGUIControl::IsFocused( void )
return false;
}
void pyGUIControl::SetVisible( hsBool vis )
void pyGUIControl::SetVisible( bool vis )
{
if ( fGCkey )
{
@ -184,7 +184,7 @@ void pyGUIControl::SetVisible( hsBool vis )
}
}
hsBool pyGUIControl::IsVisible( void )
bool pyGUIControl::IsVisible( void )
{
if ( fGCkey )
{
@ -196,7 +196,7 @@ hsBool pyGUIControl::IsVisible( void )
return false;
}
hsBool pyGUIControl::IsInteresting( void )
bool pyGUIControl::IsInteresting( void )
{
if ( fGCkey )
{
@ -208,7 +208,7 @@ hsBool pyGUIControl::IsInteresting( void )
return false;
}
void pyGUIControl::SetNotifyOnInteresting( hsBool state )
void pyGUIControl::SetNotifyOnInteresting( bool state )
{
if ( fGCkey )
{

20
Sources/Plasma/FeatureLib/pfPython/pyGUIControl.h
View File

@ -84,8 +84,8 @@ public:
static void AddPlasmaClasses(PyObject *m);
// override the equals to operator
hsBool operator==(const pyGUIControl &gcobj) const;
hsBool operator!=(const pyGUIControl &gcobj) const { return !(gcobj == *this); }
bool operator==(const pyGUIControl &gcobj) const;
bool operator!=(const pyGUIControl &gcobj) const { return !(gcobj == *this); }
// getter and setters
virtual plKey getObjKey();
@ -93,20 +93,20 @@ public:
// interface functions
virtual uint32_t GetTagID();
virtual void SetEnabled( hsBool e );
virtual void SetEnabled( bool e );
virtual void Enable() { SetEnabled(true); }
virtual void Disable() { SetEnabled(false); }
virtual hsBool IsEnabled( void );
virtual void SetFocused( hsBool e );
virtual bool IsEnabled( void );
virtual void SetFocused( bool e );
virtual void Focus() { SetFocused(true); }
virtual void UnFocus() { SetFocused(false); }
virtual hsBool IsFocused( void );
virtual void SetVisible( hsBool vis );
virtual bool IsFocused( void );
virtual void SetVisible( bool vis );
virtual void Show() { SetVisible(true); }
virtual void Hide() { SetVisible(false); }
virtual hsBool IsVisible( void );
virtual hsBool IsInteresting( void );
virtual void SetNotifyOnInteresting( hsBool state );
virtual bool IsVisible( void );
virtual bool IsInteresting( void );
virtual void SetNotifyOnInteresting( bool state );
virtual void Refresh( void );
virtual void SetObjectCenter( pyPoint3& pt);
virtual PyObject* GetObjectCenter(); // returns pyPoint3

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlButton.cpp
View File

@ -54,7 +54,7 @@ pyGUIControlButton::pyGUIControlButton(plKey objkey) : pyGUIControl(objkey)
{
}
hsBool pyGUIControlButton::IsGUIControlButton(pyKey& gckey)
bool pyGUIControlButton::IsGUIControlButton(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIButtonMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -84,7 +84,7 @@ int32_t pyGUIControlButton::GetNotifyType()
return false;
}
hsBool pyGUIControlButton::IsButtonDown()
bool pyGUIControlButton::IsButtonDown()
{
if ( fGCkey )
{

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlButton.h
View File

@ -71,11 +71,11 @@ public:
static void AddPlasmaClasses(PyObject *m);
static void AddPlasmaConstantsClasses(PyObject *m);
static hsBool IsGUIControlButton(pyKey& gckey);
static bool IsGUIControlButton(pyKey& gckey);
virtual void SetNotifyType(int32_t kind);
virtual int32_t GetNotifyType();
virtual hsBool IsButtonDown();
virtual bool IsButtonDown();
};
#endif // _pyGUIControlButton_h_

6
Sources/Plasma/FeatureLib/pfPython/pyGUIControlCheckBox.cpp
View File

@ -58,7 +58,7 @@ pyGUIControlCheckBox::pyGUIControlCheckBox(plKey objkey) : pyGUIControl(objkey)
}
hsBool pyGUIControlCheckBox::IsGUIControlCheckBox(pyKey& gckey)
bool pyGUIControlCheckBox::IsGUIControlCheckBox(pyKey& gckey)
{
if ( gckey.getKey() && pfGUICheckBoxCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -66,7 +66,7 @@ hsBool pyGUIControlCheckBox::IsGUIControlCheckBox(pyKey& gckey)
}
void pyGUIControlCheckBox::SetChecked( hsBool checked )
void pyGUIControlCheckBox::SetChecked( bool checked )
{
if ( fGCkey )
{
@ -78,7 +78,7 @@ void pyGUIControlCheckBox::SetChecked( hsBool checked )
}
hsBool pyGUIControlCheckBox::IsChecked( void )
bool pyGUIControlCheckBox::IsChecked( void )
{
if ( fGCkey )
{

6
Sources/Plasma/FeatureLib/pfPython/pyGUIControlCheckBox.h
View File

@ -72,10 +72,10 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlCheckBox(pyKey& gckey);
static bool IsGUIControlCheckBox(pyKey& gckey);
virtual void SetChecked( hsBool checked );
virtual hsBool IsChecked( void );
virtual void SetChecked( bool checked );
virtual bool IsChecked( void );
};

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlClickMap.cpp
View File

@ -59,7 +59,7 @@ pyGUIControlClickMap::pyGUIControlClickMap(plKey objkey) : pyGUIControl(objkey)
}
hsBool pyGUIControlClickMap::IsGUIControlClickMap(pyKey& gckey)
bool pyGUIControlClickMap::IsGUIControlClickMap(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIClickMapCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlClickMap.h
View File

@ -71,7 +71,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlClickMap(pyKey& gckey);
static bool IsGUIControlClickMap(pyKey& gckey);
PyObject* GetLastMousePt( void ); // returns pyPoint3
PyObject* GetLastMouseUpPt( void ); // returns pyPoint3

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDragBar.cpp
View File

@ -63,7 +63,7 @@ pyGUIControlDragBar::~pyGUIControlDragBar()
}
hsBool pyGUIControlDragBar::IsGUIControlDragBar(pyKey& gckey)
bool pyGUIControlDragBar::IsGUIControlDragBar(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIDragBarCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -93,7 +93,7 @@ void pyGUIControlDragBar::Unanchor( void )
}
}
hsBool pyGUIControlDragBar::IsAnchored()
bool pyGUIControlDragBar::IsAnchored()
{
if ( fGCkey )
{

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDragBar.h
View File

@ -75,11 +75,11 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlDragBar(pyKey& gckey);
static bool IsGUIControlDragBar(pyKey& gckey);
virtual void Anchor( void );
virtual void Unanchor( void );
virtual hsBool IsAnchored();
virtual bool IsAnchored();
};

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDraggable.cpp
View File

@ -58,14 +58,14 @@ pyGUIControlDraggable::pyGUIControlDraggable(plKey objkey) : pyGUIControl(objkey
}
hsBool pyGUIControlDraggable::IsGUIControlDraggable(pyKey& gckey)
bool pyGUIControlDraggable::IsGUIControlDraggable(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIDraggableMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
return false;
}
void pyGUIControlDraggable::StopDragging( hsBool cancel )
void pyGUIControlDraggable::StopDragging( bool cancel )
{
if ( fGCkey )
{

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDraggable.h
View File

@ -76,9 +76,9 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlDraggable(pyKey& gckey);
static bool IsGUIControlDraggable(pyKey& gckey);
void StopDragging( hsBool cancel );
void StopDragging( bool cancel );
PyObject* GetLastMousePt( void ); // returns pyPoint3
};

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDynamicText.cpp
View File

@ -59,7 +59,7 @@ pyGUIControlDynamicText::pyGUIControlDynamicText(plKey objkey) : pyGUIControl(ob
}
hsBool pyGUIControlDynamicText::IsGUIControlDynamicText(pyKey& gckey)
bool pyGUIControlDynamicText::IsGUIControlDynamicText(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIDynDisplayCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlDynamicText.h
View File

@ -73,7 +73,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlDynamicText(pyKey& gckey);
static bool IsGUIControlDynamicText(pyKey& gckey);
//specific interface functions
virtual uint32_t GetNumMaps();

8
Sources/Plasma/FeatureLib/pfPython/pyGUIControlEditBox.cpp
View File

@ -58,7 +58,7 @@ pyGUIControlEditBox::pyGUIControlEditBox(plKey objkey) : pyGUIControl(objkey)
}
hsBool pyGUIControlEditBox::IsGUIControlEditBox(pyKey& gckey)
bool pyGUIControlEditBox::IsGUIControlEditBox(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIEditBoxMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -186,7 +186,7 @@ void pyGUIControlEditBox::SetSelColor(pyColor& forecolor, pyColor& backcolor)
*/
}
hsBool pyGUIControlEditBox::WasEscaped()
bool pyGUIControlEditBox::WasEscaped()
{
if ( fGCkey )
{
@ -198,7 +198,7 @@ hsBool pyGUIControlEditBox::WasEscaped()
return false;
}
void pyGUIControlEditBox::SetSpecialCaptureKeyMode(hsBool state)
void pyGUIControlEditBox::SetSpecialCaptureKeyMode(bool state)
{
if ( fGCkey )
{
@ -244,7 +244,7 @@ void pyGUIControlEditBox::SetLastKeyCapture(uint32_t key, uint32_t modifiers)
}
}
void pyGUIControlEditBox::SetChatMode(hsBool state)
void pyGUIControlEditBox::SetChatMode(bool state)
{
if ( fGCkey )
{

8
Sources/Plasma/FeatureLib/pfPython/pyGUIControlEditBox.h
View File

@ -72,7 +72,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlEditBox(pyKey& gckey);
static bool IsGUIControlEditBox(pyKey& gckey);
virtual void SetBufferSize( uint32_t size );
virtual std::string GetBuffer( void );
@ -85,14 +85,14 @@ public:
virtual void SetColor(pyColor& forecolor, pyColor& backcolor);
virtual void SetSelColor(pyColor& forecolor, pyColor& backcolor);
virtual hsBool WasEscaped();
virtual bool WasEscaped();
virtual void SetSpecialCaptureKeyMode(hsBool state);
virtual void SetSpecialCaptureKeyMode(bool state);
virtual uint32_t GetLastKeyCaptured();
virtual uint32_t GetLastModifiersCaptured();
virtual void SetLastKeyCapture(uint32_t key, uint32_t modifiers);
virtual void SetChatMode(hsBool state);
virtual void SetChatMode(bool state);
};

24
Sources/Plasma/FeatureLib/pfPython/pyGUIControlListBox.cpp
View File

@ -163,7 +163,7 @@ class pfColorListElement : public pfGUIListText
fString1 = nil;
}
virtual hsBool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
virtual bool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
{
hsColorRGBA textColor1;
textColor1 = fTextColor1;
@ -242,7 +242,7 @@ class pfColorListElement : public pfGUIListText
virtual void GetSize( plDynamicTextMap *textGen, uint16_t *width, uint16_t *height )
{
hsBool wemade_string = false;
bool wemade_string = false;
wchar_t* thestring;
if ( fString1 && fString2 )
{
@ -327,7 +327,7 @@ class pfListPictureInBox : public pfGUIListPicture
uint32_t fSrcHeight;
public:
pfListPictureInBox( plKey mipKey, uint32_t x, uint32_t y, uint32_t width, uint32_t height, hsBool respectAlpha ) : pfGUIListPicture( mipKey,respectAlpha )
pfListPictureInBox( plKey mipKey, uint32_t x, uint32_t y, uint32_t width, uint32_t height, bool respectAlpha ) : pfGUIListPicture( mipKey,respectAlpha )
{
fSrcX = x;
fSrcY = y;
@ -335,7 +335,7 @@ class pfListPictureInBox : public pfGUIListPicture
fSrcHeight = height;
}
virtual hsBool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
virtual bool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
{
plMipmap *mip = plMipmap::ConvertNoRef( fMipmapKey->ObjectIsLoaded() );
if( mip != nil )
@ -394,7 +394,7 @@ class pfListPictureInBoxWithSwatches : public pfListPictureInBox
pfListPictureInBoxWithSwatches( plKey mipKey, uint32_t x, uint32_t y,
uint32_t width, uint32_t height,
hsBool respectAlpha,
bool respectAlpha,
const hsColorRGBA &primaryColor, const hsColorRGBA &secondaryColor )
: pfListPictureInBox( mipKey, x, y, width, height, respectAlpha )
{
@ -402,7 +402,7 @@ class pfListPictureInBoxWithSwatches : public pfListPictureInBox
fSColor = secondaryColor;
}
virtual hsBool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
virtual bool Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
{
if( !pfListPictureInBox::Draw( textGen, x, y, maxWidth, maxHeight ) )
return false;
@ -435,7 +435,7 @@ pyGUIControlListBox::pyGUIControlListBox(plKey objkey) : pyGUIControl(objkey)
{
}
hsBool pyGUIControlListBox::IsGUIControlListBox(pyKey& gckey)
bool pyGUIControlListBox::IsGUIControlListBox(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIListBoxMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -624,7 +624,7 @@ int16_t pyGUIControlListBox::AddStringW( std::wstring string )
return -1;
}
int16_t pyGUIControlListBox::AddImage( pyImage& image, hsBool respectAlpha )
int16_t pyGUIControlListBox::AddImage( pyImage& image, bool respectAlpha )
{
if ( fGCkey )
{
@ -771,7 +771,7 @@ int16_t pyGUIControlListBox::AddStringInBoxW( std::wstring string, uint32_t min_
return -1;
}
int16_t pyGUIControlListBox::AddImageInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, hsBool respectAlpha )
int16_t pyGUIControlListBox::AddImageInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, bool respectAlpha )
{
if ( fGCkey )
{
@ -788,7 +788,7 @@ int16_t pyGUIControlListBox::AddImageInBox( pyImage& image, uint32_t x, uint32
return -1;
}
int16_t pyGUIControlListBox::AddImageAndSwatchesInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, hsBool respectAlpha,
int16_t pyGUIControlListBox::AddImageAndSwatchesInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, bool respectAlpha,
pyColor &primary, pyColor &secondary )
{
if ( fGCkey )
@ -927,14 +927,14 @@ void pyGUIControlListBox::Unclickable( void )
}
}
void pyGUIControlListBox::AddBranch( const char *name, hsBool initiallyOpen )
void pyGUIControlListBox::AddBranch( const char *name, bool initiallyOpen )
{
wchar_t *wName = hsStringToWString(name);
AddBranchW(wName,initiallyOpen);
delete [] wName;
}
void pyGUIControlListBox::AddBranchW( std::wstring name, hsBool initiallyOpen )
void pyGUIControlListBox::AddBranchW( std::wstring name, bool initiallyOpen )
{
if ( fGCkey )
{

12
Sources/Plasma/FeatureLib/pfPython/pyGUIControlListBox.h
View File

@ -79,7 +79,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlListBox(pyKey& gckey);
static bool IsGUIControlListBox(pyKey& gckey);
// special case control for the listbox
// ...this allows the listbox to be used without being selectable
@ -97,9 +97,9 @@ public:
virtual std::wstring GetElementW( uint16_t idx );
virtual int16_t AddString( const char *string );
virtual int16_t AddStringW( std::wstring string );
virtual int16_t AddImage( pyImage& image, hsBool respectAlpha );
virtual int16_t AddImageInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, hsBool respectAlpha );
virtual int16_t AddImageAndSwatchesInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, hsBool respectAlpha,
virtual int16_t AddImage( pyImage& image, bool respectAlpha );
virtual int16_t AddImageInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, bool respectAlpha );
virtual int16_t AddImageAndSwatchesInBox( pyImage& image, uint32_t x, uint32_t y, uint32_t width, uint32_t height, bool respectAlpha,
pyColor &primary, pyColor &secondary );
virtual void SetSwatchSize( uint32_t size );
virtual void SetSwatchEdgeOffset( uint32_t size );
@ -125,8 +125,8 @@ public:
// To create tree branches, call AddBranch() with a name, then add elements as usual, including new sub-branches
// via additional AddBranch() calls. Call CloseBranch() to stop writing elements to that branch.
void AddBranch( const char *name, hsBool initiallyOpen );
void AddBranchW( std::wstring name, hsBool initiallyOpen );
void AddBranch( const char *name, bool initiallyOpen );
void AddBranchW( std::wstring name, bool initiallyOpen );
void CloseBranch( void );
void RemoveSelection( int32_t item );

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlMultiLineEdit.cpp
View File

@ -57,7 +57,7 @@ pyGUIControlMultiLineEdit::pyGUIControlMultiLineEdit(plKey objkey) : pyGUIContro
{
}
hsBool pyGUIControlMultiLineEdit::IsGUIControlMultiLineEdit(pyKey& gckey)
bool pyGUIControlMultiLineEdit::IsGUIControlMultiLineEdit(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIMultiLineEditCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -444,7 +444,7 @@ void pyGUIControlMultiLineEdit::Unlock( void )
}
}
hsBool pyGUIControlMultiLineEdit::IsLocked( void )
bool pyGUIControlMultiLineEdit::IsLocked( void )
{
if ( fGCkey )
{

4
Sources/Plasma/FeatureLib/pfPython/pyGUIControlMultiLineEdit.h
View File

@ -72,7 +72,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static void AddPlasmaConstantsClasses(PyObject *m);
static hsBool IsGUIControlMultiLineEdit(pyKey& gckey);
static bool IsGUIControlMultiLineEdit(pyKey& gckey);
virtual void Clickable( void );
virtual void Unclickable( void );
@ -102,7 +102,7 @@ public:
virtual void Lock( void );
virtual void Unlock( void );
virtual hsBool IsLocked( void );
virtual bool IsLocked( void );
virtual void EnableScrollControl();
virtual void DisableScrollControl();

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlRadioGroup.cpp
View File

@ -55,7 +55,7 @@ pyGUIControlRadioGroup::pyGUIControlRadioGroup(plKey objkey) : pyGUIControl(objk
{
}
hsBool pyGUIControlRadioGroup::IsGUIControlRadioGroup(pyKey& gckey)
bool pyGUIControlRadioGroup::IsGUIControlRadioGroup(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIRadioGroupCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlRadioGroup.h
View File

@ -72,7 +72,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlRadioGroup(pyKey& gckey);
static bool IsGUIControlRadioGroup(pyKey& gckey);
virtual int32_t GetValue( void );
virtual void SetValue( int32_t value );

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlTextBox.cpp
View File

@ -61,7 +61,7 @@ pyGUIControlTextBox::pyGUIControlTextBox(plKey objkey) : pyGUIControl(objkey)
}
hsBool pyGUIControlTextBox::IsGUIControlTextBox(pyKey& gckey)
bool pyGUIControlTextBox::IsGUIControlTextBox(pyKey& gckey)
{
if ( gckey.getKey() && pfGUITextBoxMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;

2
Sources/Plasma/FeatureLib/pfPython/pyGUIControlTextBox.h
View File

@ -75,7 +75,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlTextBox(pyKey& gckey);
static bool IsGUIControlTextBox(pyKey& gckey);
virtual void SetText( const char *text );
virtual void SetTextW( std::wstring text );

8
Sources/Plasma/FeatureLib/pfPython/pyGUIControlValue.cpp
View File

@ -58,7 +58,7 @@ pyGUIControlValue::pyGUIControlValue(plKey objkey) : pyGUIControl(objkey)
{
}
hsBool pyGUIControlValue::IsGUIControlValue(pyKey& gckey)
bool pyGUIControlValue::IsGUIControlValue(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIValueCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -161,7 +161,7 @@ pyGUIControlKnob::pyGUIControlKnob(plKey objkey) : pyGUIControlValue(objkey)
{
}
hsBool pyGUIControlKnob::IsGUIControlKnob(pyKey& gckey)
bool pyGUIControlKnob::IsGUIControlKnob(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIKnobCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -181,7 +181,7 @@ pyGUIControlUpDownPair::pyGUIControlUpDownPair(plKey objkey) : pyGUIControlValue
{
}
hsBool pyGUIControlUpDownPair::IsGUIControlUpDownPair(pyKey& gckey)
bool pyGUIControlUpDownPair::IsGUIControlUpDownPair(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIUpDownPairMod::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;
@ -201,7 +201,7 @@ pyGUIControlProgress::pyGUIControlProgress(plKey objkey) : pyGUIControlValue(obj
{
}
hsBool pyGUIControlProgress::IsGUIControlProgress(pyKey& gckey)
bool pyGUIControlProgress::IsGUIControlProgress(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIProgressCtrl::ConvertNoRef(gckey.getKey()->ObjectIsLoaded()) )
return true;

8
Sources/Plasma/FeatureLib/pfPython/pyGUIControlValue.h
View File

@ -70,7 +70,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlValue(pyKey& gckey);
static bool IsGUIControlValue(pyKey& gckey);
virtual float GetValue();
virtual void SetValue( float v );
@ -98,7 +98,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlKnob(pyKey& gckey);
static bool IsGUIControlKnob(pyKey& gckey);
};
class pyGUIControlUpDownPair : public pyGUIControlValue
@ -118,7 +118,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlUpDownPair(pyKey& gckey);
static bool IsGUIControlUpDownPair(pyKey& gckey);
};
class pyGUIControlProgress : public pyGUIControlValue
@ -138,7 +138,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUIControlProgress(pyKey& gckey);
static bool IsGUIControlProgress(pyKey& gckey);
void AnimateToPercentage(float percent);
};

8
Sources/Plasma/FeatureLib/pfPython/pyGUIDialog.cpp
View File

@ -86,7 +86,7 @@ pyGUIDialog::pyGUIDialog()
fGCkey = nil;
}
hsBool pyGUIDialog::IsGUIDialog(pyKey& gckey)
bool pyGUIDialog::IsGUIDialog(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIDialogMod::ConvertNoRef(gckey.getKey()->GetObjectPtr()) )
return true;
@ -135,7 +135,7 @@ uint32_t pyGUIDialog::WhatControlType(pyKey& gckey)
// override the equals to operator
hsBool pyGUIDialog::operator==(const pyGUIDialog &gcobj) const
bool pyGUIDialog::operator==(const pyGUIDialog &gcobj) const
{
plKey theirs = ((pyGUIDialog&)gcobj).getObjKey();
if ( fGCkey == nil && theirs == nil )
@ -174,7 +174,7 @@ uint32_t pyGUIDialog::GetTagID()
}
void pyGUIDialog::SetEnabled( hsBool e )
void pyGUIDialog::SetEnabled( bool e )
{
if ( fGCkey )
{
@ -184,7 +184,7 @@ void pyGUIDialog::SetEnabled( hsBool e )
}
}
hsBool pyGUIDialog::IsEnabled( void )
bool pyGUIDialog::IsEnabled( void )
{
if ( fGCkey )
{

10
Sources/Plasma/FeatureLib/pfPython/pyGUIDialog.h
View File

@ -77,7 +77,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
static void AddPlasmaMethods(std::vector<PyMethodDef> &methods);
static hsBool IsGUIDialog(pyKey& gckey);
static bool IsGUIDialog(pyKey& gckey);
void setKey(plKey key) {fGCkey = key;} // used by python glue, do NOT call
@ -105,8 +105,8 @@ public:
static void GUICursorDimmed();
// override the equals to operator
hsBool operator==(const pyGUIDialog &gdobj) const;
hsBool operator!=(const pyGUIDialog &gdobj) const { return !(gdobj == *this); }
bool operator==(const pyGUIDialog &gdobj) const;
bool operator!=(const pyGUIDialog &gdobj) const { return !(gdobj == *this); }
// getter and setters
virtual plKey getObjKey();
@ -115,10 +115,10 @@ public:
// interface functions
virtual uint32_t GetTagID();
virtual void SetEnabled( hsBool e );
virtual void SetEnabled( bool e );
virtual void Enable() { SetEnabled(true); }
virtual void Disable() { SetEnabled(false); }
virtual hsBool IsEnabled( void );
virtual bool IsEnabled( void );
virtual const char *GetName( void );
virtual uint32_t GetVersion(void);

8
Sources/Plasma/FeatureLib/pfPython/pyGUIPopUpMenu.cpp
View File

@ -182,7 +182,7 @@ void pyGUIPopUpMenu::setup(const char *name, pyGUIPopUpMenu &parent, float scree
fGCkey = nil;
}
hsBool pyGUIPopUpMenu::IsGUIPopUpMenu(pyKey& gckey)
bool pyGUIPopUpMenu::IsGUIPopUpMenu(pyKey& gckey)
{
if ( gckey.getKey() && pfGUIPopUpMenu::ConvertNoRef(gckey.getKey()->GetObjectPtr()) )
return true;
@ -191,7 +191,7 @@ hsBool pyGUIPopUpMenu::IsGUIPopUpMenu(pyKey& gckey)
// override the equals to operator
hsBool pyGUIPopUpMenu::operator==(const pyGUIPopUpMenu &gcobj) const
bool pyGUIPopUpMenu::operator==(const pyGUIPopUpMenu &gcobj) const
{
plKey theirs = ((pyGUIPopUpMenu&)gcobj).getObjKey();
if ( fGCkey == nil && theirs == nil )
@ -225,13 +225,13 @@ uint32_t pyGUIPopUpMenu::GetTagID()
}
void pyGUIPopUpMenu::SetEnabled( hsBool e )
void pyGUIPopUpMenu::SetEnabled( bool e )
{
kGetMenuPtr( ; );
menu->SetEnabled(e);
}
hsBool pyGUIPopUpMenu::IsEnabled( void )
bool pyGUIPopUpMenu::IsEnabled( void )
{
kGetMenuPtr( false );
return menu->IsEnabled();

12
Sources/Plasma/FeatureLib/pfPython/pyGUIPopUpMenu.h
View File

@ -91,11 +91,11 @@ public:
void setup(const char *name, float screenOriginX, float screenOriginY, const plLocation &destLoc = plLocation::kGlobalFixedLoc);
void setup(const char *name, pyGUIPopUpMenu &parent, float screenOriginX, float screenOriginY);
static hsBool IsGUIPopUpMenu(pyKey& gckey);
static bool IsGUIPopUpMenu(pyKey& gckey);
// override the equals to operator
hsBool operator==(const pyGUIPopUpMenu &gdobj) const;
hsBool operator!=(const pyGUIPopUpMenu &gdobj) const { return !(gdobj == *this); }
bool operator==(const pyGUIPopUpMenu &gdobj) const;
bool operator!=(const pyGUIPopUpMenu &gdobj) const { return !(gdobj == *this); }
// getter and setters
virtual plKey getObjKey();
@ -104,12 +104,12 @@ public:
// interface functions
virtual uint32_t GetTagID();
virtual void SetEnabled( hsBool e );
virtual void SetEnabled( bool e );
virtual void Enable() { SetEnabled(true); }
virtual void Disable() { SetEnabled(false); }
virtual hsBool IsEnabled( void );
virtual bool IsEnabled( void );
virtual const char *GetName( void );
virtual uint32_t GetVersion(void);
virtual uint32_t GetVersion(void);
virtual void Show( void );
virtual void Hide( void );

4
Sources/Plasma/FeatureLib/pfPython/pyGUISkin.cpp
View File

@ -63,7 +63,7 @@ pyGUISkin::pyGUISkin()
fGCkey = nil;
}
hsBool pyGUISkin::IsGUISkin(pyKey& gckey)
bool pyGUISkin::IsGUISkin(pyKey& gckey)
{
if ( gckey.getKey() && pfGUISkin::ConvertNoRef(gckey.getKey()->GetObjectPtr()) )
return true;
@ -71,7 +71,7 @@ hsBool pyGUISkin::IsGUISkin(pyKey& gckey)
}
// override the equals to operator
hsBool pyGUISkin::operator==(const pyGUISkin &gcobj) const
bool pyGUISkin::operator==(const pyGUISkin &gcobj) const
{
plKey theirs = ((pyGUISkin&)gcobj).getObjKey();
if ( fGCkey == nil && theirs == nil )

6
Sources/Plasma/FeatureLib/pfPython/pyGUISkin.h
View File

@ -74,13 +74,13 @@ public:
static void AddPlasmaClasses(PyObject *m);
static hsBool IsGUISkin(pyKey& gckey);
static bool IsGUISkin(pyKey& gckey);
void setKey(plKey key) {fGCkey = key;} // used by python glue, do NOT call
// override the equals to operator
hsBool operator==(const pyGUISkin &gdobj) const;
hsBool operator!=(const pyGUISkin &gdobj) const { return !(gdobj == *this); }
bool operator==(const pyGUISkin &gdobj) const;
bool operator!=(const pyGUISkin &gdobj) const { return !(gdobj == *this); }
// getter and setters
virtual plKey getObjKey();

4
Sources/Plasma/FeatureLib/pfPython/pyImage.h
View File

@ -123,7 +123,7 @@ public:
void setKey(pyKey& mipmapKey);
// override the equals to operator
hsBool operator==(const pyImage &image) const
bool operator==(const pyImage &image) const
{
// only thing that needs testing is the plKey, which is unique for all
if ( fMipMapKey == ((pyImage&)image).GetKey() )
@ -131,7 +131,7 @@ public:
else
return false;
}
hsBool operator!=(const pyImage &image) const { return !(image == *this); }
bool operator!=(const pyImage &image) const { return !(image == *this); }
// for C++ access
plKey GetKey() { return fMipmap ? fMipmap->GetKey() : fMipMapKey; }

4
Sources/Plasma/FeatureLib/pfPython/pyJournalBook.cpp
View File

@ -164,7 +164,7 @@ void pyJournalBook::MakeBook(std::wstring esHTMLSource, plKey coverImageKey /* =
IMakeNewKey();
}
void pyJournalBook::Show( hsBool startOpened )
void pyJournalBook::Show( bool startOpened )
{
if( fBook != nil )
fBook->Show( startOpened );
@ -276,7 +276,7 @@ PyObject *pyJournalBook::GetMovie(uint8_t index)
PYTHON_RETURN_NONE;
}
void pyJournalBook::SetEditable( hsBool editable )
void pyJournalBook::SetEditable( bool editable )
{
if (fBook != nil)
fBook->SetEditable(editable);

4
Sources/Plasma/FeatureLib/pfPython/pyJournalBook.h
View File

@ -98,7 +98,7 @@ public:
void MakeBook(std::wstring esHTMLSource, plKey coverImageKey = nil, plKey callbackKey = nil, plString guiName = _TEMP_CONVERT_FROM_LITERAL(""));
// Interface functions per book
virtual void Show( hsBool startOpened );
virtual void Show( bool startOpened );
virtual void Hide( void );
virtual void Open( uint32_t startingPage );
virtual void Close( void );
@ -121,7 +121,7 @@ public:
virtual PyObject *GetMovie( uint8_t index ); // returns cyAnimation
virtual void SetEditable( hsBool editable );
virtual void SetEditable( bool editable );
virtual std::string GetEditableText( void ) const;
virtual void SetEditableText( std::string text );
};

27
Sources/Plasma/FeatureLib/pfPython/pyKey.cpp
View File

@ -80,28 +80,9 @@ pyKey::pyKey(plKey key, plPythonFileMod* pymod)
fPyFileMod=pymod;
fNetForce=false;
}
void pyKey::SetNetForce(hsBool state)
{
// set our flag
fNetForce = state;
}
// send enable message to the plKey
void pyKey::Enable()
{
IEnable(true);
}
// send disable message to the plKey
void pyKey::Disable()
{
IEnable(false);
}
#endif
hsBool pyKey::operator==(const pyKey &key) const
bool pyKey::operator==(const pyKey &key) const
{
plKey ours = ((pyKey*)this)->getKey();
plKey theirs = ((pyKey&)key).getKey();
@ -137,7 +118,7 @@ PyObject* pyKey::GetPySceneObject()
}
// send disable message to the plKey
void pyKey::IEnable(hsBool state)
void pyKey::IEnable(bool state)
{
// create message
plEnableMsg* pMsg = new plEnableMsg;
@ -177,7 +158,7 @@ PyObject* pyKey::GetParentObject()
// special functions when the plKey is a pointer to the PythonModifier
//
// Was the last plNotifyMsg a locally sent?
hsBool pyKey::WasLocalNotify()
bool pyKey::WasLocalNotify()
{
// see if we have a PythonFileModifier pointer
if ( fPyFileMod )
@ -187,7 +168,7 @@ hsBool pyKey::WasLocalNotify()
}
// Is python file mod attached to clone
hsBool pyKey::IsAttachedToClone()
bool pyKey::IsAttachedToClone()
{
// see if we have a PythonFileModifier pointer
if ( fPyFileMod )

18
Sources/Plasma/FeatureLib/pfPython/pyKey.h
View File

@ -63,7 +63,7 @@ private:
#ifndef BUILDING_PYPLASMA // pyPlasma (and other plugins) don't need all this extra junk)
plPythonFileMod* fPyFileMod; // pointer to the PythonFileModifier
hsBool fNetForce;
bool fNetForce;
#endif // BUILDING_PYPLASMA
protected:
@ -89,8 +89,8 @@ public:
static void AddPlasmaClasses(PyObject *m);
// override the equals to operator
hsBool operator==(const pyKey &key) const;
hsBool operator!=(const pyKey &key) const { return !(key == *this); }
bool operator==(const pyKey &key) const;
bool operator!=(const pyKey &key) const { return !(key == *this); }
// getter and setters
virtual plKey getKey() { return fKey; }
@ -99,13 +99,13 @@ public:
#ifndef BUILDING_PYPLASMA
PyObject* GetPySceneObject();
virtual void SetNetForce(hsBool state);
virtual void SetNetForce(bool state) { fNetForce = state; }
// methods to be sent to the plKey
// send enable message to the plKey
virtual void Enable();
virtual void Enable() { IEnable(true); }
// send disable message to the plKey
virtual void Disable();
virtual void Disable() { IEnable(false); }
// if this is a modifier then get the (first) object its attached to
virtual PyObject* GetParentObject();
@ -113,9 +113,9 @@ public:
// (Only called from C++, not from Python directly)
//
// Was the last plNotifyMsg a locally sent?
virtual hsBool WasLocalNotify();
virtual bool WasLocalNotify();
// Is this python file mod attached to a clone?
virtual hsBool IsAttachedToClone();
virtual bool IsAttachedToClone();
// (old style - Used in pyNotify)
// get the notify list count
virtual int32_t NotifyListCount();
@ -132,7 +132,7 @@ public:
virtual plPipeline* GetPipeline();
private:
// build and send enable message to the plKey
virtual void IEnable(hsBool state);
virtual void IEnable(bool state);
#endif // BUILDING_PYPLASMA
};

2
Sources/Plasma/FeatureLib/pfPython/pyMatrix44.h
View File

@ -83,7 +83,7 @@ public:
void MakeRotateMat(int axis, float radians) { fMatrix.MakeRotateMat(axis, radians); }
void Make(const pyPoint3& from, const pyPoint3& at, const pyVector3& up);
void MakeUpPreserving(const pyPoint3& from, const pyPoint3& at, const pyVector3& up);
hsBool GetParity() const { return fMatrix.GetParity(); }
bool GetParity() const { return fMatrix.GetParity(); }
float GetDeterminant() const { return fMatrix.GetDeterminant(); }
PyObject* GetInverse(PyObject* inverse) const; // returns (and accepts) pyMatrix44
PyObject* GetTranspose(PyObject* inverse) const; // returns (and accepts) pyMatrix44

6
Sources/Plasma/FeatureLib/pfPython/pyNetLinkingMgr.cpp
View File

@ -55,14 +55,14 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "pyAgeInfoStruct.h"
#include "pyAgeLinkStruct.h"
hsBool pyNetLinkingMgr::IsEnabled( void ) const
bool pyNetLinkingMgr::IsEnabled( void ) const
{
return plNetLinkingMgr::GetInstance()->IsEnabled();
}
void pyNetLinkingMgr::SetEnabled( hsBool b )
void pyNetLinkingMgr::SetEnabled( bool b ) const
{
plNetLinkingMgr::GetInstance()->SetEnabled( b?true:false );
plNetLinkingMgr::GetInstance()->SetEnabled( b );
}
void pyNetLinkingMgr::LinkToAge( pyAgeLinkStruct & link, const char* linkAnim )

4
Sources/Plasma/FeatureLib/pfPython/pyNetLinkingMgr.h
View File

@ -76,8 +76,8 @@ public:
#ifndef BUILDING_PYPLASMA
// enable/disable linking
hsBool IsEnabled( void ) const;
void SetEnabled( hsBool b );
bool IsEnabled( void ) const;
void SetEnabled( bool b ) const;
// Link to a public instance. PLS will load balance.
void LinkToAge( pyAgeLinkStruct & link, const char* linkAnim );

22
Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp
View File

@ -101,16 +101,6 @@ void pyNotify::AddReceiver(pyKey* key)
fReceivers.Append(key->getKey());
}
void pyNotify::SetNetPropagate(hsBool propagate)
{
fNetPropagate = propagate;
}
void pyNotify::SetNetForce(hsBool state)
{
fNetForce = state;
}
void pyNotify::SetActivateState(float state)
{
@ -127,13 +117,13 @@ void pyNotify::SetType(int32_t type)
// Add event record helpers
//////////////////////////////////////////////////
void pyNotify::AddCollisionEvent( hsBool enter, pyKey* other, pyKey* self )
void pyNotify::AddCollisionEvent( bool enter, pyKey* other, pyKey* self )
{
fBuildMsg.AddCollisionEvent(enter, other ? other->getKey() : plKey(),
self ? self->getKey() : plKey() );
}
void pyNotify::AddPickEvent( hsBool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint)
void pyNotify::AddPickEvent( bool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint)
{
fBuildMsg.AddPickEvent( other ? other->getKey() : plKey(),
self ? self->getKey() : plKey(),
@ -141,7 +131,7 @@ void pyNotify::AddPickEvent( hsBool enabled, pyKey* other, pyKey* self, pyPoint3
hitPoint.fPoint );
}
void pyNotify::AddControlKeyEvent( int32_t key, hsBool down )
void pyNotify::AddControlKeyEvent( int32_t key, bool down )
{
fBuildMsg.AddControlKeyEvent(key,down);
}
@ -166,21 +156,21 @@ void pyNotify::AddVarKey(const char* name, pyKey* key)
fBuildMsg.AddVariableEvent(name, key ? key->getKey() : plKey() );
}
void pyNotify::AddFacingEvent( hsBool enabled, pyKey* other, pyKey* self, float dot)
void pyNotify::AddFacingEvent( bool enabled, pyKey* other, pyKey* self, float dot)
{
fBuildMsg.AddFacingEvent( other ? other->getKey() : plKey(),
self ? self->getKey() : plKey(),
dot, enabled);
}
void pyNotify::AddContainerEvent( hsBool entering, pyKey* contained, pyKey* container)
void pyNotify::AddContainerEvent( bool entering, pyKey* contained, pyKey* container)
{
fBuildMsg.AddContainerEvent( container ? container->getKey() : plKey(),
contained ? contained->getKey() : plKey() ,
entering);
}
void pyNotify::AddActivateEvent( hsBool active, hsBool activate )
void pyNotify::AddActivateEvent( bool active, bool activate )
{
fBuildMsg.AddActivateEvent(activate);
}

20
Sources/Plasma/FeatureLib/pfPython/pyNotify.h
View File

@ -60,8 +60,8 @@ private:
// the list of receivers that want to be notified
hsTArray<plKey> fReceivers;
hsBool fNetPropagate;
hsBool fNetForce;
bool fNetPropagate;
bool fNetForce;
// notify message build area
plNotifyMsg fBuildMsg;
@ -87,22 +87,22 @@ public:
// methods that will be exposed to Python
virtual void ClearReceivers();
virtual void AddReceiver(pyKey* key);
virtual void SetNetPropagate(hsBool propagate);
virtual void SetNetForce(hsBool state);
virtual void SetNetPropagate(bool propagate) { fNetPropagate = propagate; }
virtual void SetNetForce(bool state) { fNetForce = state; }
virtual void SetActivateState(float state);
virtual void SetType(int32_t type);
// add event record helpers
virtual void AddCollisionEvent( hsBool enter, pyKey* other, pyKey* self );
virtual void AddPickEvent(hsBool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint);
virtual void AddControlKeyEvent( int32_t key, hsBool down );
virtual void AddCollisionEvent( bool enter, pyKey* other, pyKey* self );
virtual void AddPickEvent(bool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint);
virtual void AddControlKeyEvent( int32_t key, bool down );
virtual void AddVarNumber(const char* name, float number);
virtual void AddVarNumber(const char* name, int number);
virtual void AddVarNull(const char* name);
virtual void AddVarKey(const char* name, pyKey* key);
virtual void AddFacingEvent( hsBool enabled, pyKey* other, pyKey* self, float dot);
virtual void AddContainerEvent( hsBool entering, pyKey* container, pyKey* contained);
virtual void AddActivateEvent( hsBool active, hsBool activate );
virtual void AddFacingEvent( bool enabled, pyKey* other, pyKey* self, float dot);
virtual void AddContainerEvent( bool entering, pyKey* container, pyKey* contained);
virtual void AddActivateEvent( bool active, bool activate );
virtual void AddCallbackEvent( int32_t event );
virtual void AddResponderState(int32_t state);

20
Sources/Plasma/FeatureLib/pfPython/pyPlayer.cpp
View File

@ -95,23 +95,3 @@ void pyPlayer::Init(plKey avKey, const char* pname, uint32_t pid, float distsq)
fIsCCR = false;
fIsServer = false;
}
void pyPlayer::SetCCRFlag(hsBool state)
{
fIsCCR = state;
}
hsBool pyPlayer::IsCCR()
{
return fIsCCR;
}
void pyPlayer::SetServerFlag(hsBool state)
{
fIsServer = state;
}
hsBool pyPlayer::IsServer()
{
return fIsServer;
}

23
Sources/Plasma/FeatureLib/pfPython/pyPlayer.h
View File

@ -59,8 +59,8 @@ protected:
std::string fPlayerName;
uint32_t fPlayerID;
float fDistSq; // from local player, temp
hsBool fIsCCR;
hsBool fIsServer;
bool fIsCCR;
bool fIsServer;
pyPlayer(); // only used by python glue, do NOT call
pyPlayer(pyKey& avKey, const char* pname, uint32_t pid, float distsq);
@ -81,7 +81,7 @@ public:
static void AddPlasmaClasses(PyObject *m);
// override the equals to operator
hsBool operator==(const pyPlayer &player) const
bool operator==(const pyPlayer &player) const
{
// only thing that needs testing is the playerid, which is unique for all
if ( ((pyPlayer*)this)->GetPlayerID() == player.GetPlayerID() )
@ -89,25 +89,22 @@ public:
else
return false;
}
hsBool operator!=(const pyPlayer &player) const { return !(player == *this); }
bool operator!=(const pyPlayer &player) const { return !(player == *this); }
// for C++ access
plKey GetKey() { return fAvatarKey; }
plKey GetKey() const { return fAvatarKey; }
// for python access
const char * GetPlayerName() const { return fPlayerName.c_str();}
uint32_t GetPlayerID() const
{
return fPlayerID;
}
uint32_t GetPlayerID() const { return fPlayerID; }
float GetDistSq() const { return fDistSq; }
void SetCCRFlag(hsBool state);
hsBool IsCCR();
void SetCCRFlag(bool state) { fIsCCR = state; }
bool IsCCR() const { return fIsCCR; }
void SetServerFlag(hsBool state);
hsBool IsServer();
void SetServerFlag(bool state) { fIsServer = state; }
bool IsServer() const { return fIsServer; }
};

22
Sources/Plasma/FeatureLib/pfPython/pySceneObject.cpp
View File

@ -149,7 +149,7 @@ pySceneObject::~pySceneObject()
}
hsBool pySceneObject::operator==(const pySceneObject &sobj) const
bool pySceneObject::operator==(const pySceneObject &sobj) const
{
plKey ours = ((pySceneObject*)this)->getObjKey();
plKey theirs = ((pySceneObject&)sobj).getObjKey();
@ -207,17 +207,7 @@ void pySceneObject::setSenderKey(plKey key)
ISetAllSenderKeys();
}
void pySceneObject::setPyMod(pyKey& pymod)
{
fPyMod = pymod.getKey();
}
void pySceneObject::setPyMod(plKey& key)
{
fPyMod = key;
}
void pySceneObject::SetNetForce(hsBool state)
void pySceneObject::SetNetForce(bool state)
{
// set our flag
fNetForce = state;
@ -264,7 +254,7 @@ PyObject* pySceneObject::findObj(const plString& name)
//
// deteremine if this object (or the first object in the list)
// ...is locally owned
hsBool pySceneObject::IsLocallyOwned()
bool pySceneObject::IsLocallyOwned()
{
// make sure that there are sceneobjects
if ( fSceneObjects.Count() > 0 )
@ -536,7 +526,7 @@ PyObject* pySceneObject::GetRightVector()
//
// deteremine if this object (or any of the object attached)
// ...is an avatar, of any type
hsBool pySceneObject::IsAvatar()
bool pySceneObject::IsAvatar()
{
// loop through all the sceneobject... looking for avatar modifiers
int j;
@ -602,7 +592,7 @@ PyObject* pySceneObject::GetAvatarVelocity()
//
// deteremine if this object (or the first object in the list)
// ...is a human avatar
hsBool pySceneObject::IsHumanAvatar()
bool pySceneObject::IsHumanAvatar()
{
// loop through all the sceneobject... looking for avatar modifiers
int j;
@ -636,7 +626,7 @@ hsBool pySceneObject::IsHumanAvatar()
}
// switch to / from this object (assuming that it is actually a camera)
void pySceneObject::PushCutsceneCamera(hsBool cut, pyKey& avKey)
void pySceneObject::PushCutsceneCamera(bool cut, pyKey& avKey)
{
if ( fSceneObjects.Count() > 0 )
{

21
Sources/Plasma/FeatureLib/pfPython/pySceneObject.h
View File

@ -61,8 +61,7 @@ private:
hsTArray<plKey> fSceneObjects;
plKey fSenderKey; // the holder of the who (the modifier) we are
plKey fPyMod; // pyKey that points to modifier
hsBool fNetForce;
bool fNetForce;
virtual void IAddObjKeyToAll(plKey key);
virtual void ISetAllSenderKeys();
@ -88,8 +87,8 @@ public:
static void AddPlasmaClasses(PyObject *m);
// override the equals to operator
hsBool operator==(const pySceneObject &sobj) const;
hsBool operator!=(const pySceneObject &sobj) const { return !(sobj == *this); }
bool operator==(const pySceneObject &sobj) const;
bool operator!=(const pySceneObject &sobj) const { return !(sobj == *this); }
PyObject* fDraw; // cyDraw
PyObject* fPhysics; // cyPhysics
@ -103,10 +102,10 @@ public:
virtual PyObject* getObjPyKey(); // pyKey
virtual void setSenderKey(plKey key);
virtual void setPyMod(pyKey& pymod);
virtual void setPyMod(plKey& key);
virtual void setPyMod(pyKey& pymod) { fPyMod = pymod.getKey(); }
virtual void setPyMod(const plKey& key) { fPyMod = key; }
virtual void SetNetForce(hsBool state);
virtual void SetNetForce(bool state);
virtual PyObject* findObj(const plString& name); // pySceneObject
@ -116,7 +115,7 @@ public:
//
// deteremine if this object (or the first object in the list)
// ...is locally owned
virtual hsBool IsLocallyOwned();
virtual bool IsLocallyOwned();
//
// get the local to world matrix
@ -157,14 +156,14 @@ public:
//
// deteremine if this object (or any of the object attached)
// ...is an avatar, of any type
virtual hsBool IsAvatar();
virtual bool IsAvatar();
virtual PyObject* GetAvatarVelocity(); // pyVector3
//
// deteremine if this object (or the first object in the list)
// ...is a human avatar
virtual hsBool IsHumanAvatar();
virtual bool IsHumanAvatar();
//
// switch to / from this camera (if it is a camera)
@ -172,7 +171,7 @@ public:
void PushCamera(pyKey& avKey);
void PushCameraCut(pyKey& avKey);
void PopCamera(pyKey& avKey);
void PushCutsceneCamera(hsBool cut,pyKey& avKey);
void PushCutsceneCamera(bool cut, pyKey& avKey);
void PopCutsceneCamera(pyKey& avKey);
void Animate();

13
Sources/Plasma/FeatureLib/pfPython/pyStatusLog.cpp
View File

@ -65,7 +65,7 @@ pyStatusLog::~pyStatusLog()
}
hsBool pyStatusLog::Open(plString logName, uint32_t numLines, uint32_t flags)
bool pyStatusLog::Open(plString logName, uint32_t numLines, uint32_t flags)
{
// make sure its closed first
Close();
@ -81,7 +81,7 @@ hsBool pyStatusLog::Open(plString logName, uint32_t numLines, uint32_t flags)
return false;
}
hsBool pyStatusLog::Write(plString text)
bool pyStatusLog::Write(plString text)
{
if (fLog)
{
@ -92,7 +92,7 @@ hsBool pyStatusLog::Write(plString text)
return false;
}
hsBool pyStatusLog::WriteColor(plString text, pyColor& color)
bool pyStatusLog::WriteColor(plString text, pyColor& color)
{
if (fLog)
{
@ -115,10 +115,3 @@ void pyStatusLog::Close()
}
fLog = nil;
}
hsBool pyStatusLog::IsOpen()
{
if (fLog)
return true;
return false;
}

8
Sources/Plasma/FeatureLib/pfPython/pyStatusLog.h
View File

@ -78,12 +78,12 @@ public:
static void AddPlasmaClasses(PyObject *m);
static void AddPlasmaConstantsClasses(PyObject *m);
virtual hsBool Open(plString logName, uint32_t numLines, uint32_t flags);
virtual hsBool Write(plString text);
virtual hsBool WriteColor(plString text, pyColor& color);
virtual bool Open(plString logName, uint32_t numLines, uint32_t flags);
virtual bool Write(plString text);
virtual bool WriteColor(plString text, pyColor& color);
virtual void Close();
virtual hsBool IsOpen();
virtual bool IsOpen() { return (fLog != nil); }
};

11
Sources/Plasma/FeatureLib/pfPython/pyStream.cpp
View File

@ -61,7 +61,7 @@ pyStream::~pyStream()
}
hsBool pyStream::Open(const wchar_t* fileName, const wchar_t* flags)
bool pyStream::Open(const wchar_t* fileName, const wchar_t* flags)
{
// make sure its closed first
Close();
@ -124,7 +124,7 @@ std::vector<std::string> pyStream::ReadLines()
return pyPL;
}
hsBool pyStream::WriteLines(const std::vector<std::string> & lines)
bool pyStream::WriteLines(const std::vector<std::string> & lines)
{
if (fStream)
{
@ -150,10 +150,3 @@ void pyStream::Close()
}
fStream = nil;
}
hsBool pyStream::IsOpen()
{
if (fStream)
return true;
return false;
}

6
Sources/Plasma/FeatureLib/pfPython/pyStream.h
View File

@ -75,12 +75,12 @@ public:
static void AddPlasmaClasses(PyObject *m);
virtual hsBool Open(const wchar_t* fileName, const wchar_t* flags);
virtual bool Open(const wchar_t* fileName, const wchar_t* flags);
virtual std::vector<std::string> ReadLines();
virtual hsBool WriteLines(const std::vector<std::string> & lines);
virtual bool WriteLines(const std::vector<std::string> & lines);
virtual void Close();
virtual hsBool IsOpen();
virtual bool IsOpen() { return (fStream != nil); }
};

4
Sources/Plasma/FeatureLib/pfPython/pyVaultAgeInfoListNode.cpp
View File

@ -69,7 +69,7 @@ pyVaultAgeInfoListNode::pyVaultAgeInfoListNode(int n)
//==================================================================
// class RelVaultNode : public plVaultFolderNode
//
hsBool pyVaultAgeInfoListNode::HasAge(uint32_t ageID)
bool pyVaultAgeInfoListNode::HasAge(uint32_t ageID)
{
if (!fNode)
return false;
@ -78,7 +78,7 @@ hsBool pyVaultAgeInfoListNode::HasAge(uint32_t ageID)
return false;
}
hsBool pyVaultAgeInfoListNode::AddAge( uint32_t ageID )
bool pyVaultAgeInfoListNode::AddAge( uint32_t ageID )
{
if (!fNode)
return false;

6
Sources/Plasma/FeatureLib/pfPython/pyVaultAgeInfoListNode.h
View File

@ -77,9 +77,9 @@ public:
//==================================================================
// class RelVaultNode : public plVaultFolderNode
//
hsBool HasAge( uint32_t ageID );
hsBool AddAge( uint32_t ageID );
void RemoveAge( uint32_t ageID );
bool HasAge( uint32_t ageID );
bool AddAge( uint32_t ageID );
void RemoveAge( uint32_t ageID );
};
#endif // _pyVaultAgeInfoListNode_h_

2
Sources/Plasma/FeatureLib/pfPython/pyVaultNode.cpp
View File

@ -500,7 +500,7 @@ void pyVaultNode::LinkToNode(int nodeID, PyObject* cbObject, uint32_t cbContext)
}
// Remove child node
hsBool pyVaultNode::RemoveNode( pyVaultNode& pynode, PyObject* cbObject, uint32_t cbContext )
bool pyVaultNode::RemoveNode( pyVaultNode& pynode, PyObject* cbObject, uint32_t cbContext )
{
pyVaultNodeOperationCallback * cb = NEWZERO(pyVaultNodeOperationCallback)( cbObject );

2
Sources/Plasma/FeatureLib/pfPython/pyVaultNode.h
View File

@ -158,7 +158,7 @@ public:
// Link node to this one
void LinkToNode(int nodeID, PyObject* cbObject=nil, uint32_t cbContext=0 );
// Remove child node
hsBool RemoveNode( pyVaultNode& pynode, PyObject* cbObject=nil, uint32_t cbContext=0 );
bool RemoveNode( pyVaultNode& pynode, PyObject* cbObject=nil, uint32_t cbContext=0 );
// Remove all child nodes
void RemoveAllNodes( void );
// Add/Save this node to vault

4
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerInfoListNode.cpp
View File

@ -74,7 +74,7 @@ pyVaultPlayerInfoListNode::pyVaultPlayerInfoListNode(int n)
//==================================================================
// class RelVaultNode : public plVaultFolderNode
//
hsBool pyVaultPlayerInfoListNode::HasPlayer( uint32_t playerID )
bool pyVaultPlayerInfoListNode::HasPlayer( uint32_t playerID )
{
if (!fNode)
return false;
@ -93,7 +93,7 @@ hsBool pyVaultPlayerInfoListNode::HasPlayer( uint32_t playerID )
return (rvn != nil);
}
hsBool pyVaultPlayerInfoListNode::AddPlayer( uint32_t playerID )
bool pyVaultPlayerInfoListNode::AddPlayer( uint32_t playerID )
{
if (HasPlayer(playerID))
return true;

4
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerInfoListNode.h
View File

@ -78,8 +78,8 @@ public:
//==================================================================
// class RelVaultNode : public plVaultFolderNode
//
virtual hsBool HasPlayer( uint32_t playerID );
hsBool AddPlayer( uint32_t playerID );
virtual bool HasPlayer( uint32_t playerID );
bool AddPlayer( uint32_t playerID );
void RemovePlayer( uint32_t playerID );
PyObject * GetPlayer( uint32_t playerID ); // returns pyVaultPlayerInfoNode

2
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerInfoNode.cpp
View File

@ -178,7 +178,7 @@ void pyVaultPlayerInfoNode::Player_SetOnline( bool b )
playerInfo.SetOnline(b);
}
hsBool pyVaultPlayerInfoNode::Player_IsOnline( void )
bool pyVaultPlayerInfoNode::Player_IsOnline( void )
{
if (!fNode)
return false;

2
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerInfoNode.h
View File

@ -91,7 +91,7 @@ public:
const char * Player_GetAgeGuid( void );
// online status
void Player_SetOnline( bool b );
hsBool Player_IsOnline( void );
bool Player_IsOnline( void );
int Player_GetCCRLevel( void );
};

2
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerNode.cpp
View File

@ -325,7 +325,7 @@ void pyVaultPlayerNode::SetExplorer (bool b) {
player.SetExplorer(b);
}
hsBool pyVaultPlayerNode::IsExplorer () {
bool pyVaultPlayerNode::IsExplorer () {
if (!fNode)
return false;

2
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerNode.h
View File

@ -113,7 +113,7 @@ public:
uint32_t GetOnlineTime();
void SetExplorer (bool b);
hsBool IsExplorer ();
bool IsExplorer ();
};
#endif // pyVaultPlayerNode_h_