pcce Namespace Reference

Highest-level namespace for the Protocce engine. More...


Classes

class  Configuration
class  DeleteSceneEvent
class  EventConnectionManager
class  EventDispatcher
class  EventSystem
 Event system class. More...
class  Exception
 Base class for all Protocce exceptions. More...
class  GameObject
 GameObjects are used to hold any game related info the engine user wants. More...
class  GameObjectDB
class  EndStateEvent
class  IEvent
 Base event class. More...
class  EventType
 Event type template. More...
class  IGameState
 Base game state class. More...
class  InputSubSystem
class  InputTranslator
class  IProcess
 Base process class. More...
class  IResource
class  IResourceFactory
class  ISerializable
class  ISerializeNode
 Base Serialize Node. More...
class  ISerializer
 Base Serializer Interface. More...
class  ISound
class  ISubSystem
class  IThreadedSubSystem
class  Log
class  Matrix4
 4x4 Matrix class More...
class  NoOpProcess
 Simple process that does nothing. More...
class  OggFile
class  OggStream
class  OpenALSource
class  ProcessList
class  PropertyBag
class  Protocce
 Main class to wrap up the engine. More...
class  RenderSubSystem
class  RequestWindowHandleEvent
class  ResourceManager
class  Scene
class  SceneChangeEvent
class  XmlSerializeNode
class  XmlSerializer
class  SetInputTranslatorEvent
class  Singleton
 Singleton template class. More...
class  ScopedSingleton
 Scoped singleton manager template class. More...
class  SoundBuffer
class  SoundBufferEvent
class  SoundStreamEvent
class  SoundResource
class  SoundResourceFactory
class  SoundStream
class  SoundSubSystem
class  ThreadExceptionEvent
class  Timer
 Timer class More...
class  UpdateSubSystemEvent
class  Variant
 Variant class that can store a single value of many types. More...
class  VariantException
 Base class for Variant-related exceptions. More...
class  VariantEmptyException
 Exception that is thrown when attempting to get a value from an empty Variant. More...
class  VariantConversionException
 Exception that is thrown when a type conversion fails. More...
class  Vector3
 3 dimensional vector class More...
class  Vector4
 4 dimensional vector class More...
class  WaitProcess
class  XmlDoc
class  XmlNode
class  OgreLog

Typedefs

typedef float tReal
 Floating point type used by the engine, it is set via cmake.
typedef boost::shared_ptr
< Configuration > 		tConfigurationPtr
typedef boost::function< void(const
tIEventPtr &) > 		tEventHandler
typedef boost::signals::connection tEventConnection
typedef pcce::Singleton
< EventSystem > 		EventSystemSingleton
 Event system singleton.
typedef unsigned int tGameObjectID
typedef boost::shared_ptr
< GameObject > 		tGameObjectPtr
typedef Singleton< GameObjectDB > GameObjectDBSingleton
typedef boost::shared_ptr< IEvent > tIEventPtr
typedef std::list< tIEventPtr > tIEventPtrList
typedef boost::shared_ptr
< IGameState > 		tIGameStatePtr
typedef boost::function
< tIEventPtr(const
OIS::KeyCode KeyCode, const
tKeyState KeyState) > 		tKeyInputToEvent
typedef boost::function
< tIEventPtr(const
OIS::MouseState &ms) > 		tMouseMoveToEvent
typedef boost::function
< tIEventPtr(const
OIS::MouseState &ms, const
OIS::MouseButtonID mbid, const
tKeyState state) > 		tMouseClickToEvent
typedef boost::shared_ptr
< InputTranslator > 		tInputTranslatorPtr
typedef boost::shared_ptr
< IProcess > 		tIProcessPtr
typedef std::list
< pcce::tIProcessPtr > 		tIProcessPtrList
typedef boost::intrusive_ptr
< IResource > 		tIResourcePtr
typedef boost::shared_ptr
< ISerializeNode > 		tISerializeNodePtr
typedef boost::function< void() > tStaticLoadFunction
typedef boost::function< void(tISerializeNodePtr
Node) > 		tRegisterSaveFunction
typedef unsigned int tSoundID
typedef boost::shared_ptr
< ISubSystem > 		tISubSystemPtr
typedef std::list< tISubSystemPtr > tISubSystemPtrList
typedef pcce::Singleton< Log > LogSingleton
typedef std::vector< char > tCharVector
typedef boost::shared_ptr
< OggStream > 		tOggStreamPtr
typedef boost::shared_ptr
< OpenALSource > 		tOpenALSourcePtr
typedef boost::shared_ptr
< ProcessList > 		tProcessListPtr
typedef boost::shared_ptr
< PropertyBag > 		tPropertyBagPtr
typedef boost::shared_ptr
< IResourceFactory > 		tIResourceFactoryPtr
typedef pcce::Singleton
< ResourceManager > 		ResourceManagerSingleton
typedef boost::shared_ptr< Scene > tScenePtr
typedef unsigned int tTimerKey
 Unique ID for custom timers.
typedef boost::shared_ptr< Timer > tTimerPtr
typedef std::size_t tHashValue
typedef unsigned long tMillisecond
 Unit of time in milliseconds.
typedef boost::variant< int,
unsigned int, long int,
unsigned long int, tReal, char,
unsigned char, std::string,
tPropertyBagPtr > 		tVariant
 Underlying type used by Variant class.
typedef std::list< Variant > tVariantList
 std::list of Variants, used by pcce::Format()

Enumerations

enum  tKeyState { ksUp, ksDown }
enum  tSoundAction { saPlay, saPause, saStop, saReleaseSource }
 Enumeration used to tell sound system what to do. More...
enum  tLogLevel { llNone = 0, llQuiet, llLoud, llDebug }
enum  tMessageLevel { mlQuiet = 1, mlLoud, mlDebug }
enum  tCompareResult { crLess, crEqual, crGreater }

Functions

std::string GetPcceName ()
 Function to get the project name, it is set via cmake.
std::string GetPcceCMakeSystemStr ()
 Function to get the system Protocce was compiled on, it is set via cmake.
std::string GetPcceCMakeProcessorStr ()
 Function to get the processor Protocce was compiled on, it is set via cmake.
std::string GetPcceCMakeBuildTypeStr ()
 Function to get the Protocce build type (debug or release), it is set via cmake.
std::string GetPcceVersionStr ()
 Function to get the version string (Major.Minor.Revision), it is set via cmake.
unsigned short GetPcceVersionMajor ()
 Function to get the major version number, it is set via cmake.
unsigned short GetPcceVersionMinor ()
 Function to get the minor version number, it is set via cmake.
unsigned short GetPcceVersionRevision ()
 Function to get the revision version number, it is set via cmake.
std::string GetPcceFullVersionStr ()
std::string GetPcceBuilderName ()
 Function to return the builder's name, it is set via cmake.
unsigned int GetPcceBuildNumber ()
 Function to get the build number, it is set via cmake.
std::string GetPcceFullBuildInfoStr ()
 Function to return the full build info string (includes the version, system, and builder info).
template<class T>
void check (bool condition, const std::string &error, const std::string &fileName, const unsigned int lineNumber)
 This function throws an exception if the condition is false.
void SetActiveInputTranslator (const tInputTranslatorPtr &translator)
template<class T>
tIEventPtr CreateEvent ()
void intrusive_ptr_add_ref (IResource *r)
void intrusive_ptr_release (IResource *r)
void HandleThreadExceptionEvent (const tIEventPtr &event)
tCompareResult CompareReal (const tReal &x, const tReal &y)
bool SameReal (const tReal &x, const tReal &y)
tReal RoundTo (const tReal &x, unsigned short digits)
tReal Truncate (const tReal &x)
bool IsNaN (const tReal &x)
bool IsInf (const tReal &x)
template<typename T>
tCompareResult Compare (const T &a, const T &b)
template<typename T>
tCompareResult Sign (const T &a)
void InitializeAL ()
 Initialize OpenAL.
void ShutdownAL ()
 Shutdown OpenAL.
ALuint LoadOgg (const std::string &fileName)
 Load an ogg file into buffer.
ALuint LoadWav (const std::string &fileName)
 Load a wave file into buffer.
ALuint GenSource ()
ALuint GenSource (ALuint buffer)
void ClearALError ()
const std::string & GetALErrorStr (const ALenum error)
tHashValue HashString (const std::string &s)
std::string Format (const std::string &formatStr, const tVariantList values)
 Very basic format function.
std::string GetNL ()
 Return newline for the current platform.
void SleepMs (tMillisecond time)
 Cross-platform sleep function.
tMillisecond GetTimeSinceStart ()
 Returns the time in milliseconds since the application was started.
bool operator== (const XmlNode &a, const XmlNode &b)
bool operator!= (const XmlNode &a, const XmlNode &b)
bool operator== (const XmlNode &a, const void *b)
bool operator!= (const XmlNode &a, const void *b)
static unsigned short readByte16 (const unsigned char buffer[2])
static unsigned long readByte32 (const unsigned char buffer[4])
tHashValue HashString (const string &s)
string Format (const string &formatStr, const tVariantList values)
ostream & operator<< (ostream &s, const Vector3 &v)
ostream & operator<< (ostream &s, const Vector4 &v)

Variables

const tHashValue AllEventsType = 0
const tGameObjectID InvalidGameObjectID = 0
const std::string kMaterialNameProperty = "MaterialName"
const std::string kRenderModelNameProperty = "RenderModelName"
const std::string kPhysicsModelNameProperty = "PhysicsModelName"
const tReal Pi = static_cast< tReal>(M_PI)
const tReal TwoPi = static_cast< tReal>(2 * M_PI)
const tReal PiDiv2 = static_cast< tReal>(M_PI / 2)
const std::string SoundResourceType = "SoundResource"
const tMillisecond msPerS = 1000
const tMillisecond usPerMs = 1000

Detailed Description

Highest-level namespace for the Protocce engine.

This is the namespace that all Protocce code belongs to. Certain sub-systems will have nested namespaces to help distinguish them, but everything will belong to the "pcce" namespace.

Typedef Documentation

typedef pcce::Singleton<EventSystem> pcce::EventSystemSingleton

Event system singleton.

Definition at line 102 of file EventSystem.h.

typedef Singleton< GameObjectDB > pcce::GameObjectDBSingleton

Definition at line 64 of file GameObjectDB.h.

typedef pcce::Singleton< Log > pcce::LogSingleton

Definition at line 67 of file Log.h.

typedef pcce::Singleton< ResourceManager > pcce::ResourceManagerSingleton

Definition at line 93 of file ResourceManager.h.

typedef std::vector< char > pcce::tCharVector

Definition at line 43 of file OggFile.h.

typedef boost::shared_ptr< Configuration > pcce::tConfigurationPtr

Definition at line 50 of file Configuration.h.

typedef boost::signals::connection pcce::tEventConnection

Definition at line 47 of file EventDispatcherFwd.h.

typedef boost::function< void (const tIEventPtr&) > pcce::tEventHandler

Definition at line 46 of file EventDispatcherFwd.h.

typedef unsigned int pcce::tGameObjectID

Definition at line 43 of file GameObject.h.

typedef boost::shared_ptr< GameObject > pcce::tGameObjectPtr

Definition at line 77 of file GameObject.h.

typedef std::size_t pcce::tHashValue

Definition at line 41 of file util.h.

typedef boost::shared_ptr< IEvent > pcce::tIEventPtr

Definition at line 43 of file IEventFwd.h.

typedef std::list< tIEventPtr > pcce::tIEventPtrList

Definition at line 46 of file IEventFwd.h.

typedef boost::shared_ptr< IGameState > pcce::tIGameStatePtr

Definition at line 41 of file IGameStateFwd.h.

typedef boost::shared_ptr< InputTranslator > pcce::tInputTranslatorPtr

Definition at line 75 of file InputTranslator.h.

typedef boost::shared_ptr< IProcess > pcce::tIProcessPtr

Definition at line 44 of file IProcess.h.

typedef std::list< pcce::tIProcessPtr > pcce::tIProcessPtrList

Definition at line 47 of file IProcess.h.

typedef boost::shared_ptr< IResourceFactory > pcce::tIResourceFactoryPtr

Definition at line 45 of file ResourceManager.h.

typedef boost::intrusive_ptr< IResource > pcce::tIResourcePtr

Definition at line 78 of file IResource.h.

typedef boost::shared_ptr< ISerializeNode > pcce::tISerializeNodePtr

Definition at line 44 of file ISerializeNode.h.

typedef boost::shared_ptr< ISubSystem > pcce::tISubSystemPtr

Definition at line 54 of file ISubSystem.h.

typedef std::list< tISubSystemPtr > pcce::tISubSystemPtrList

Definition at line 55 of file ISubSystem.h.

typedef boost::function< tIEventPtr (const OIS::KeyCode KeyCode, const tKeyState KeyState) > pcce::tKeyInputToEvent

Definition at line 49 of file InputTranslator.h.

typedef unsigned long pcce::tMillisecond

Unit of time in milliseconds.

Definition at line 44 of file util.h.

typedef boost::function< tIEventPtr (const OIS::MouseState &ms, const OIS::MouseButtonID mbid, const tKeyState state) > pcce::tMouseClickToEvent

Definition at line 52 of file InputTranslator.h.

typedef boost::function< tIEventPtr (const OIS::MouseState &ms) > pcce::tMouseMoveToEvent

Definition at line 50 of file InputTranslator.h.

typedef boost::shared_ptr< OggStream > pcce::tOggStreamPtr

Definition at line 82 of file OggStream.h.

typedef boost::shared_ptr< OpenALSource > pcce::tOpenALSourcePtr

Definition at line 51 of file OpenALSource.h.

typedef boost::shared_ptr< ProcessList > pcce::tProcessListPtr

Definition at line 69 of file ProcessList.h.

typedef boost::shared_ptr< PropertyBag > pcce::tPropertyBagPtr

Definition at line 46 of file PropertyBag.h.

typedef float pcce::tReal

Floating point type used by the engine, it is set via cmake.

Definition at line 83 of file config.h.

typedef boost::function< void (tISerializeNodePtr Node) > pcce::tRegisterSaveFunction

Definition at line 47 of file ISerializer.h.

typedef boost::shared_ptr< Scene > pcce::tScenePtr

Definition at line 72 of file Scene.h.

typedef unsigned int pcce::tSoundID

Definition at line 39 of file ISound.h.

typedef boost::function< void () > pcce::tStaticLoadFunction

Definition at line 46 of file ISerializer.h.

typedef unsigned int pcce::tTimerKey

Unique ID for custom timers.

This type is used to uniquely identify custom timers. It is used for all custom timer methods.

See also:
Timer::StartCustomTimer()

Timer::GetCustomTimerStartTime()

Timer::CheckCustomTimer()

Timer::EndCustomTimer()

Timer::ResetCustomTimer()

Timer::IsCustomTimerActive()

Definition at line 56 of file Timer.h.

typedef boost::shared_ptr< Timer > pcce::tTimerPtr

Definition at line 41 of file TimerFwd.h.

typedef boost::variant< int, unsigned int, long int, unsigned long int, tReal, char, unsigned char, std::string, tPropertyBagPtr > pcce::tVariant

Underlying type used by Variant class.

This is the underlying boost::variant type that is used by the Variant class. Note that bool is intentionally not included here, even though IsBool and AsBool exist. That is because const char* will be implicitly converted to a bool if it is included. A bool can be converted to an int automatically, so leaving it out allows us to still have AsBool/IsBool but also keep the automatic conversion from a string literal to a Variant.

Definition at line 56 of file Variant.h.

typedef std::list< Variant > pcce::tVariantList

std::list of Variants, used by pcce::Format()

Definition at line 41 of file VariantFwd.h.

Enumeration Type Documentation

enum pcce::tCompareResult

Enumerator:
crLess 
crEqual 
crGreater 

Definition at line 50 of file mathutil.h.

00050 { crLess, crEqual, crGreater } tCompareResult;

enum pcce::tKeyState

Enumerator:
ksUp 
ksDown 

Definition at line 47 of file InputTranslator.h.

00047 { ksUp, ksDown } tKeyState;

enum pcce::tLogLevel

Enumerator:
llNone 
llQuiet 
llLoud 
llDebug 

Definition at line 44 of file Log.h.

00044 { llNone = 0, llQuiet, llLoud, llDebug } tLogLevel;

enum pcce::tMessageLevel

Enumerator:
mlQuiet 
mlLoud 
mlDebug 

Definition at line 45 of file Log.h.

00045 { mlQuiet = 1, mlLoud, mlDebug } tMessageLevel;

enum pcce::tSoundAction

Enumeration used to tell sound system what to do.

Enumerator:
saPlay 
saPause 
saStop 
saReleaseSource 

Definition at line 42 of file ISound.h.

00042 { saPlay, saPause, saStop, saReleaseSource } tSoundAction;

Function Documentation

template<class T>
void pcce::check ( bool  condition,
const std::string &  error,
const std::string &  fileName,
const unsigned int  lineNumber 
) [inline]

This function throws an exception if the condition is false.

Definition at line 107 of file Exception.h.

00107                                                                                                                {
00108     BOOST_STATIC_ASSERT(
00109       (boost::is_class< T >::value) && ((boost::is_same< pcce::Exception, T >::value) || (boost::is_base_of< pcce::Exception, T >::value)));
00110     if (!condition) {
00111       throw(T(error, fileName, lineNumber));
00112     }
00113   }

void pcce::ClearALError (  ) 

Definition at line 366 of file soundutil.cpp.

Referenced by pcce::OggStream::EmptyQueuedBuffers(), pcce::OggStream::FillBuffer(), GenSource(), InitializeAL(), LoadOgg(), LoadWav(), pcce::OggStream::OggStream(), pcce::OggStream::Pause(), pcce::OggStream::Play(), pcce::OggStream::ProcessedBuffers(), pcce::OggStream::QueueBuffer(), pcce::OggStream::QueuedBufferCount(), ShutdownAL(), pcce::OggStream::Stop(), pcce::OggStream::Update(), pcce::SoundResource::vDoUnload(), pcce::SoundSubSystem::vInitializeThread(), pcce::SoundSubSystem::vShutdownThread(), pcce::OggStream::~OggStream(), and pcce::OpenALSource::~OpenALSource().

00366                         {
00367   alGetError();
00368 }

template<typename T>
tCompareResult pcce::Compare ( const T &  a,
const T &  b 
) [inline]

Definition at line 62 of file mathutil.h.

References crEqual, crGreater, and crLess.

Referenced by GetTimeSinceStart(), and Sign().

00062                                                                         {
00063     if (a > b) {
00064       return crGreater;
00065     } else if (a < b) {
00066       return crLess;
00067     } else {
00068       return crEqual;
00069     }
00070   }

tCompareResult pcce::CompareReal ( const tReal &  x,
const tReal &  y 
)

Definition at line 40 of file mathutil.cpp.

References crEqual, crGreater, crLess, IsInf(), IsNaN(), PCCE_CHECK, and Sign().

Referenced by SameReal().

00040                                                                {
00041   PCCE_CHECK(!IsNaN(x) && !IsNaN(y), "CompareReal: Cannot compare NaN");
00042 
00043   if (x == y) {
00044     return crEqual;
00045   } else if (IsInf(x)) {
00046     if (IsInf(y)) {
00047       // We already know that x != y.  Since they are both infinity, one
00048       //   must be -inf, while the other is +inf.  Just return the sign of
00049       //   x.  If x = inf, then y = -inf and x is greater.  If x = -inf,
00050       //  then y = inf, so x is less than y.
00051       return Sign(x);
00052     } else {
00053       return (x > y) ? crGreater : crLess;
00054     }
00055   } else if (IsInf(y)) {
00056     return (x > y) ? crGreater : crLess;
00057   } else {
00058     // This is * 20 because the epsilon itself is too small.  In my quick test,
00059     //   * 20.0 seemed to give decent results.
00060     const tReal e = std::numeric_limits< tReal >::epsilon() * static_cast< tReal >(20.0);
00061     tReal result = x - y;
00062     if (result < e) {
00063       if (result > -e) {
00064         return crEqual;
00065       } else {
00066         return crLess;
00067       }
00068     } else {
00069       return crGreater;
00070     }
00071   }
00072 }

template<class T>
tIEventPtr pcce::CreateEvent (  )  [inline]

Definition at line 79 of file InputTranslator.h.

00079                                                {
00080     BOOST_STATIC_ASSERT(
00081       (boost::is_class< T >::value) && (boost::is_base_of< pcce::IEvent, T >::value));
00082     tIEventPtr result(new T());
00083     return result;
00084   }

string pcce::Format ( const string &  formatStr,
const tVariantList  values 
)

Definition at line 48 of file stringutil.cpp.

References PCCE_CHECK, and PCCE_THROW.

00048                                                                       {
00049   const char EscapeChar = '|';
00050   const char FormatChar = '%';
00051 
00052   ostringstream s;
00053   bool prevEscape = false;
00054   tVariantList::const_iterator valueIter = values.begin();
00055   
00056   for(string::const_iterator i = formatStr.begin(); i != formatStr.end(); ++i) {
00057     char c = *i;
00058 
00059     if (prevEscape) {
00060       switch (c) {
00061         case EscapeChar:
00062         case FormatChar:
00063           s << c;
00064           break;
00065         default:
00066           PCCE_THROW(string("Invalid escape character \"") + c + string("\""));
00067           break;
00068       }
00069     } else if (c == FormatChar) {
00070       PCCE_CHECK(valueIter != values.end(), "Too few values passed for format string");
00071       s << (*valueIter).AsString();
00072       ++valueIter;
00073     } else if (c != EscapeChar) {
00074       s << c;
00075     }
00076 
00077     prevEscape = (!prevEscape) && (c == EscapeChar);
00078   }
00079   return s.str();
00080 }

std::string pcce::Format ( const std::string &  formatStr,
const tVariantList  values 
)

Very basic format function.

This function provides basic format functionality. It takes a format string and a tVariantList (std::list of Variant). Any '' characters in the format string are replaced with the corresponding Variant value as as string. You can escape the '' using a '|'. If you want a '|' in the final output, you must use "||". Use of a single '|' with any other character will result in an exception. Extra values are ignored (e.g. passing 3 Variants with a format string with 1 ''), while passing too few values results in an exception.

Note: '|' is used instead of '\' to avoid confusing due to C++ treating '\' as an escape character in strings. If we used '\', the string "% Test\\ %\%" would be written in code as "% Test\\\\ %\\%". That just seems ugly. We are already doing unusual things with our Format, so a different escape character doesn't seem like that big of an issue.

For example, Format("% Test|| %|%", [ "ABC", 98, 0 ]) will return "ABC Test| 98%".

Referenced by pcce::SoundSubSystem::SanityCheck(), and pcce::SoundSubSystem::vInitializeThread().

ALuint pcce::GenSource ( ALuint  buffer  ) 

Definition at line 356 of file soundutil.cpp.

References ClearALError(), GenSource(), and PCCE_CHECK.

00356                                     {
00357   ClearALError();
00358   ALuint source = GenSource();
00359   alSourcei(source, AL_BUFFER, buffer);
00360 
00361   PCCE_CHECK(alGetError() == AL_NO_ERROR, "GenSource: Could not set source buffer");
00362 
00363   return source;
00364 }

ALuint pcce::GenSource (  ) 

Definition at line 333 of file soundutil.cpp.

References ClearALError(), and PCCE_CHECK.

Referenced by GenSource().

00333                        {
00334   ALuint source;
00335   bool looping = false;
00336   ALfloat sourcePos[] = {0.0, 0.0, 0.0};
00337   ALfloat sourceVel[] = {0.0, 0.0, 0.0};
00338 
00339   ClearALError();
00340 
00341   // Bind buffer with a source.
00342   alGenSources(1, &source);
00343   PCCE_CHECK(alGetError() == AL_NO_ERROR, "GenSource: Could not generate source");
00344 
00345   alSourcef(source, AL_PITCH, 1.0);
00346   alSourcef(source, AL_GAIN, 1.0);
00347   alSourcefv(source, AL_POSITION, sourcePos);
00348   alSourcefv(source, AL_VELOCITY, sourceVel);
00349   alSourcei(source, AL_LOOPING, looping);
00350 
00351   PCCE_CHECK(alGetError() == AL_NO_ERROR, "GenSource: Could not set source attributes");
00352 
00353   return source;
00354 }

const std::string & pcce::GetALErrorStr ( const ALenum  error  ) 

Definition at line 370 of file soundutil.cpp.

References ALInvalidEnumStr, ALInvalidNameStr, ALInvalidOpStr, ALInvalidValueStr, ALNoErrorStr, ALOtherErrorStr, and ALOutOfMemoryStr.

Referenced by pcce::OggStream::EmptyQueuedBuffers().

00370                                                        {
00371   switch(error) {
00372     case AL_NO_ERROR:
00373       return ALNoErrorStr;
00374       break;
00375     case AL_INVALID_NAME:
00376       return ALInvalidNameStr;
00377       break;
00378     case AL_INVALID_ENUM:
00379       return ALInvalidEnumStr;
00380       break;
00381     case AL_INVALID_VALUE:
00382       return ALInvalidValueStr;
00383       break;
00384     case AL_INVALID_OPERATION:
00385       return ALInvalidOpStr;
00386       break;
00387     case AL_OUT_OF_MEMORY:
00388       return ALOutOfMemoryStr;
00389       break;
00390     default:
00391       return ALOtherErrorStr;
00392       break;
00393   }
00394   // Avoid warning in OSX
00395   return ALOtherErrorStr;
00396 }

string pcce::GetNL (  ) 

Return newline for the current platform.

Definition at line 82 of file stringutil.cpp.

Referenced by pcce::Protocce::Initialize(), and pcce::Protocce::Shutdown().

00082                    {
00083   ostringstream s;
00084   s << endl;
00085   return s.str();
00086 }

std::string pcce::GetPcceBuilderName (  )  [inline]

Function to return the builder's name, it is set via cmake.

Definition at line 118 of file config.h.

Referenced by GetPcceFullBuildInfoStr().

00118 { return "dthulson"; };

unsigned int pcce::GetPcceBuildNumber (  ) 

Function to get the build number, it is set via cmake.

Definition at line 45 of file config.cpp.

Referenced by GetPcceFullVersionStr().

00045                                       {
00046   return 67;
00047 }

std::string pcce::GetPcceCMakeBuildTypeStr (  )  [inline]

Function to get the Protocce build type (debug or release), it is set via cmake.

Definition at line 100 of file config.h.

Referenced by GetPcceFullBuildInfoStr().

00100 { return "Debug"; };

std::string pcce::GetPcceCMakeProcessorStr (  )  [inline]

Function to get the processor Protocce was compiled on, it is set via cmake.

Definition at line 97 of file config.h.

Referenced by GetPcceFullBuildInfoStr().

00097 { return "i386"; };

std::string pcce::GetPcceCMakeSystemStr (  )  [inline]

Function to get the system Protocce was compiled on, it is set via cmake.

Definition at line 94 of file config.h.

Referenced by GetPcceFullBuildInfoStr().

00094 { return "Darwin-9.2.0"; };

std::string pcce::GetPcceFullBuildInfoStr (  ) 

Function to return the full build info string (includes the version, system, and builder info).

Definition at line 49 of file config.cpp.

References GetPcceBuilderName(), GetPcceCMakeBuildTypeStr(), GetPcceCMakeProcessorStr(), GetPcceCMakeSystemStr(), GetPcceFullVersionStr(), and GetPcceName().

Referenced by pcce::Protocce::Initialize().

00049                                         {
00050   std::stringstream s;
00051   s << GetPcceName() << " " << GetPcceFullVersionStr() << " "
00052     << GetPcceCMakeBuildTypeStr() << std::endl
00053     << "Built by " << GetPcceBuilderName() << " on " << GetPcceCMakeSystemStr()
00054     << " " << GetPcceCMakeProcessorStr();
00055   return s.str();
00056 }

std::string pcce::GetPcceFullVersionStr (  ) 

Definition at line 39 of file config.cpp.

References GetPcceBuildNumber(), and GetPcceVersionStr().

Referenced by GetPcceFullBuildInfoStr().

00039                                       {
00040   std::stringstream s;
00041   s << GetPcceVersionStr() << " build " << GetPcceBuildNumber();
00042   return s.str();
00043 }

std::string pcce::GetPcceName (  )  [inline]

Function to get the project name, it is set via cmake.

Note: This is a little silly, but it should not change and it makes getting the full build info string easier.

Definition at line 91 of file config.h.

Referenced by GetPcceFullBuildInfoStr().

00091 { return "Protocce"; };

unsigned short pcce::GetPcceVersionMajor (  )  [inline]

Function to get the major version number, it is set via cmake.

Definition at line 106 of file config.h.

00106 { return 0; };

unsigned short pcce::GetPcceVersionMinor (  )  [inline]

Function to get the minor version number, it is set via cmake.

Definition at line 109 of file config.h.

00109 { return 0; };

unsigned short pcce::GetPcceVersionRevision (  )  [inline]

Function to get the revision version number, it is set via cmake.

Definition at line 112 of file config.h.

00112 { return 1; };

std::string pcce::GetPcceVersionStr (  )  [inline]

Function to get the version string (Major.Minor.Revision), it is set via cmake.

Definition at line 103 of file config.h.

Referenced by GetPcceFullVersionStr().

00103 { return "0.0.1"; };

tMillisecond pcce::GetTimeSinceStart (  ) 

Returns the time in milliseconds since the application was started.

This function returns the time in milliseconds since the application was started. Note: On most systems (32-bit at least), this value will wrap after approximately 49.7 days. That is currently a limitation of our engine.

Definition at line 78 of file util.cpp.

References Compare(), crEqual, crGreater, crLess, gCurrentMutex, gLastTime, gStartTime, msPerS, PCCE_CHECK, PCCE_THROW, and usPerMs.

Referenced by pcce::Timer::CheckCustomTimer(), pcce::ProcessList::ExecuteProcesses(), pcce::Timer::ResetCustomTimer(), and pcce::Timer::StartCustomTimer().

00078                                      {
00079   boost::mutex::scoped_lock lock(gCurrentMutex);
00080   tMillisecond current;
00081 #ifdef WIN32
00082   DWORD now = timeGetTime();
00083   if (now < gStartTime) {
00084     PCCE_CHECK(gIncrement == 0, "gIncrement is not zero (multiple timer wraps?)");
00085     const DWORD maxTime = -1;
00086     gIncrement = maxTime - gStartTime;
00087     gStartTime = 0;
00088   }
00089   current = now - gStartTime + gIncrement;
00090 #else
00091   timeval t;
00092   PCCE_CHECK(gettimeofday(&t, NULL) == 0, "gettimeofday failed");
00093   
00094   current = 0;
00095   switch (Compare(t.tv_sec, gStartTime.tv_sec)) {
00096     case crLess:
00097       break;
00098     case crEqual:
00099       if (t.tv_usec > gStartTime.tv_usec) {
00100         current = (t.tv_usec - gStartTime.tv_usec) / usPerMs;
00101       }
00102       break;
00103     case crGreater:
00104       current = ((t.tv_sec - 1 - gStartTime.tv_sec) * msPerS)
00105         + ((t.tv_usec + ((1 * msPerS * usPerMs) - gStartTime.tv_usec)) / usPerMs);
00106       break;
00107     default:
00108       PCCE_THROW("Unexpected Compare result");
00109       break;
00110   }
00111 #endif
00112   if (current < gLastTime) {
00113     PCCE_THROW("Timer running backwards");
00114     //current = gLastTime;
00115   }
00116   gLastTime = current;
00117   return gLastTime;
00118 }

void pcce::HandleThreadExceptionEvent ( const tIEventPtr &  event  ) 

Definition at line 170 of file IThreadedSubSystem.cpp.

References PCCE_CHECK, and pcce::EventType< T >::sGetEventType().

Referenced by pcce::Protocce::Initialize().

00170                                                              {
00171   PCCE_CHECK(event->vGetEventType() == ThreadExceptionEvent::sGetEventType(), "HandleThreadExceptionEvent: Unexpected event type");
00172 
00173   boost::shared_ptr<ThreadExceptionEvent> e = boost::dynamic_pointer_cast<ThreadExceptionEvent>(event);
00174   throw(pcce::Exception(e->GetError(), e->GetFileName(), e->GetLineNumber()));
00175 }

tHashValue pcce::HashString ( const string &  s  ) 

Definition at line 43 of file stringutil.cpp.

00043                                            {
00044   boost::hash<string> string_hash;
00045   return string_hash(s);
00046 }

tHashValue pcce::HashString ( const std::string &  s  ) 

Referenced by pcce::EventType< pcce::SoundStreamEvent >::sGetEventType().

void pcce::InitializeAL (  ) 

Initialize OpenAL.

Definition at line 51 of file soundutil.cpp.

References ClearALError(), PCCE_CHECK, PCCE_THROW, and ShutdownAL().

Referenced by pcce::SoundSubSystem::vInitializeThread().

00051                         {
00052   ClearALError();
00053   
00054   PCCE_CHECK(alcGetCurrentContext() == NULL, "AL already initialized");
00055 
00056   ALCdevice* device = alcOpenDevice(NULL); // select the "preferred device"
00057   PCCE_CHECK(device != NULL, "InitializeAL: Cannot open preferred device");
00058   if (alcGetError(device) != ALC_NO_ERROR) {
00059     alcCloseDevice(device);
00060     PCCE_THROW("InitializeAL: Could not open device (alc error)");
00061   }
00062 
00063   // TODO: check the context attributes, maybe something is useful:
00064   // http://www.openal.org/openal_webstf/specs/oal11spec_html/oal11spec6.html
00065   // 6.2.1. Context Attributes
00066   // my bet is on ALC_STEREO_SOURCES ;-)
00067   ALCcontext* context = alcCreateContext(device, NULL);
00068   if (context == NULL) {
00069     alcCloseDevice(device);
00070     PCCE_THROW("InitializeAL: Could not create context");
00071   }
00072   if (alcGetError(device) != ALC_NO_ERROR) {
00073     alcDestroyContext(context);
00074     alcCloseDevice(device);
00075     PCCE_THROW("InitializeAL: Could not open device (alc error)");
00076   }
00077 
00078   if (alcMakeContextCurrent(context) != ALC_TRUE) {
00079     alcDestroyContext(context);
00080     alcCloseDevice(device);
00081     PCCE_THROW("InitializeAL: Could not make context current");
00082   }
00083   if (alcGetError(device) != ALC_NO_ERROR) {
00084     alcMakeContextCurrent(NULL);
00085     alcDestroyContext(context);
00086     alcCloseDevice(device);
00087     PCCE_THROW("InitializeAL: Could not make context current (alc error)");
00088   }
00089 
00090   ClearALError();
00091 
00092   // Should the listener be set here?  It seems to be set to a default, and
00093   //   eventually I'd like to have a SetALListener method that takes pcce
00094   //   vectors (once we get vectors done).
00095 
00096   //--- listener config -------------------------------------
00097   ALfloat listenerPos[] = { 0.0, 0.0, 0.0 };
00098   ALfloat listenerVel[] = { 0.0, 0.0, 0.0 };
00099 
00100   // Orientation of the listener. (first 3 elements are "at",
00101   // second 3 are "up")
00102   ALfloat listenerOri[] = { 0.0, 0.0, -1.0,  0.0, 1.0, 0.0 };
00103 
00104   alListenerfv(AL_POSITION, listenerPos);
00105   alListenerfv(AL_VELOCITY, listenerVel);
00106   alListenerfv(AL_ORIENTATION, listenerOri);
00107   if (alGetError() != AL_NO_ERROR) {
00108     ShutdownAL();
00109     PCCE_THROW("InitializeAL: Could not set listener position");
00110   }
00111   //---------------------------------------------------------
00112 }

void pcce::intrusive_ptr_add_ref ( IResource *  r  ) 

Definition at line 94 of file IResource.cpp.

References pcce::IResource::AddRef(), and PCCE_CHECK.

00094                                              {
00095   PCCE_CHECK(r != NULL, "IResource intrusive_ptr_add_ref: r is NULL");
00096   r->AddRef();
00097 }

void pcce::intrusive_ptr_release ( IResource *  r  ) 

Definition at line 99 of file IResource.cpp.

References PCCE_CHECK, and pcce::IResource::Release().

00099                                              {
00100   PCCE_CHECK(r != NULL, "IResource intrusive_ptr_release: r is NULL");
00101   if (r->Release() == 0) {
00102     delete r;
00103   }
00104 }

bool pcce::IsInf ( const tReal &  x  ) 

Definition at line 100 of file mathutil.cpp.

Referenced by CompareReal(), RoundTo(), and Truncate().

00100                                {
00101   return (std::numeric_limits< tReal >::infinity() == x)
00102     || (-std::numeric_limits< tReal >::infinity() == x);
00103 }

bool pcce::IsNaN ( const tReal &  x  ) 

Definition at line 96 of file mathutil.cpp.

Referenced by CompareReal(), RoundTo(), and Truncate().

00096                                {
00097   return std::numeric_limits< tReal >::quiet_NaN() == x;
00098 }

ALuint pcce::LoadOgg ( const std::string &  fileName  ) 

Load an ogg file into buffer.

Definition at line 136 of file soundutil.cpp.

References ClearALError(), pcce::OggFile::Close(), pcce::OggFile::GetChannelCount(), pcce::OggFile::GetFrequency(), pcce::OggFile::Open(), PCCE_CHECK, PCCE_THROW, and pcce::OggFile::Read().

Referenced by pcce::SoundResource::vDoLoad().

00136                                               {
00137   ALuint buffer = AL_NONE;
00138   ALenum format;
00139   ALsizei freq;
00140   tCharVector data;
00141   OggFile f(fileName);
00142   f.Open();
00143 
00144   // Check the number of channels... always use 16-bit samples
00145   switch(f.GetChannelCount()) {
00146     case 1:
00147       format = AL_FORMAT_MONO16;
00148       break;
00149     case 2:
00150       format = AL_FORMAT_STEREO16;
00151       break;
00152     default:
00153       PCCE_THROW("Ogg file must have 1 or 2 channels");
00154   }
00155   freq = f.GetFrequency();
00156   
00157   f.Read(data);
00158   f.Close();
00159 
00160   ClearALError();
00161   try {    
00162     alGenBuffers(1, &buffer);
00163     PCCE_CHECK(alGetError() == AL_NO_ERROR, "LoadOgg: Could not generate buffer");
00164     PCCE_CHECK(AL_NONE != buffer, "LoadOgg: Could not generate buffer");
00165 
00166     alBufferData(buffer, format, &data[0], data.size(), freq);
00167     PCCE_CHECK(alGetError() == AL_NO_ERROR, "LoadOgg: Could not load buffer data");
00168 
00169     return buffer;
00170   } catch (Exception& e) {
00171     if ((buffer != AL_NONE) && (alIsBuffer(buffer) == AL_TRUE)) {
00172       alDeleteBuffers(1, &buffer);
00173     }
00174     ClearALError();
00175     throw (e);
00176   }
00177 }

ALuint pcce::LoadWav ( const std::string &  fileName  ) 

Load a wave file into buffer.

Definition at line 204 of file soundutil.cpp.

References BUFFER_SIZE, ClearALError(), PCCE_CHECK, PCCE_THROW, readByte16(), and readByte32().

00204                                               {
00205   const unsigned int BUFFER_SIZE = 32768;     // 32 KB buffers
00206   long bytes;
00207   vector <char> data;
00208   ALenum format;
00209   ALsizei freq;
00210 
00211   // Local resources
00212   FILE *f = NULL;
00213   char *array = NULL;
00214   ALuint buffer = AL_NONE;
00215 
00216   ClearALError();
00217 
00218   // Main process
00219   try {
00220 
00221     // Open for binary reading
00222     f = fopen(fileName.c_str(), "rb");
00223     if (!f)
00224       PCCE_THROW("LoadWav: Could not load wav from " + fileName);
00225 
00226     // buffers
00227     char magic[5];
00228     magic[4] = '\0';
00229     unsigned char buffer32[4];
00230     unsigned char buffer16[2];
00231 
00232     // check magic
00233     PCCE_CHECK(fread(magic,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00234     PCCE_CHECK(std::string(magic) == "RIFF", "LoadWav: Wrong wav file format. This file is not a .wav file (no RIFF magic): "+ fileName );
00235 
00236     // skip 4 bytes (file size)
00237     fseek(f,4,SEEK_CUR);
00238 
00239     // check file format
00240     PCCE_CHECK(fread(magic,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00241     PCCE_CHECK(std::string(magic) == "WAVE", "LoadWav: Wrong wav file format. This file is not a .wav file (no WAVE format): "+ fileName );
00242 
00243     // check 'fmt ' sub chunk (1)
00244     PCCE_CHECK(fread(magic,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00245     PCCE_CHECK(std::string(magic) == "fmt ", "LoadWav: Wrong wav file format. This file is not a .wav file (no 'fmt ' subchunk): "+ fileName );
00246 
00247     // read (1)'s size
00248     PCCE_CHECK(fread(buffer32,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00249     unsigned long subChunk1Size = readByte32(buffer32);
00250     PCCE_CHECK(subChunk1Size >= 16, "Wrong wav file format. This file is not a .wav file ('fmt ' chunk too small, truncated file?): "+ fileName );
00251 
00252     // check PCM audio format
00253     PCCE_CHECK(fread(buffer16,2,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00254     unsigned short audioFormat = readByte16(buffer16);
00255     PCCE_CHECK(audioFormat == 1, "LoadWav: Wrong wav file format. This file is not a .wav file (audio format is not PCM): "+ fileName );
00256 
00257     // read number of channels
00258     PCCE_CHECK(fread(buffer16,2,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00259     unsigned short channels = readByte16(buffer16);
00260 
00261     // read frequency (sample rate)
00262     PCCE_CHECK(fread(buffer32,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00263     unsigned long frequency = readByte32(buffer32);
00264 
00265     // skip 6 bytes (Byte rate (4), Block align (2))
00266     fseek(f,6,SEEK_CUR);
00267 
00268     // read bits per sample
00269     PCCE_CHECK(fread(buffer16,2,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00270     unsigned short bps = readByte16(buffer16);
00271 
00272     if (channels == 1)
00273       format = (bps == 8) ? AL_FORMAT_MONO8 : AL_FORMAT_MONO16;
00274     else
00275       format = (bps == 8) ? AL_FORMAT_STEREO8 : AL_FORMAT_STEREO16;
00276 
00277     // check 'data' sub chunk (2)
00278     PCCE_CHECK(fread(magic,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00279     PCCE_CHECK(std::string(magic) == "data", "LoadWav: Wrong wav file format. This file is not a .wav file (no data subchunk): "+ fileName );
00280 
00281     PCCE_CHECK(fread(buffer32,4,1,f) == 1, "LoadWav: Cannot read wav file "+ fileName );
00282     unsigned long subChunk2Size = readByte32(buffer32);
00283 
00284     // The frequency of the sampling rate
00285     freq = frequency;
00286     PCCE_CHECK(sizeof(freq) == sizeof(frequency), "LoadWav: freq and frequency different sizes");
00287 
00288     array = new char[BUFFER_SIZE];
00289 
00290     while (data.size() != subChunk2Size) {
00291       // Read up to a buffer's worth of decoded sound data
00292       bytes = fread(array, 1, BUFFER_SIZE, f);
00293 
00294       if (bytes <= 0)
00295         break;
00296 
00297       if (data.size() + bytes > subChunk2Size)
00298        bytes = subChunk2Size - data.size();
00299 
00300       // Append to end of buffer
00301       data.insert(data.end(), array, array + bytes);
00302     };
00303 
00304     delete []array;
00305     array = NULL;
00306 
00307     fclose(f);
00308     f = NULL;
00309 
00310     alGenBuffers(1, &buffer);
00311     PCCE_CHECK(alGetError() == AL_NO_ERROR, "LoadWav: Could not generate buffer");
00312     PCCE_CHECK(AL_NONE != buffer, "LoadWav: Could not generate buffer");
00313 
00314     alBufferData(buffer, format, &data[0], data.size(), freq);
00315     PCCE_CHECK(alGetError() == AL_NO_ERROR, "LoadWav: Could not load buffer data");
00316 
00317     return buffer;
00318   } catch (Exception e) {
00319     if (buffer)
00320       if (alIsBuffer(buffer) == AL_TRUE)
00321         alDeleteBuffers(1, &buffer);
00322 
00323     if (array)
00324       delete []array;
00325 
00326     if (f)
00327       fclose(f);
00328 
00329     throw (e);
00330   }
00331 }

bool pcce::operator!= ( const XmlNode &  a,
const void *  b 
) [inline]

Definition at line 94 of file XmlNode.h.

References pcce::XmlNode::mElement.

00094                                                           {
00095     return a.mElement != b;
00096   }

bool pcce::operator!= ( const XmlNode &  a,
const XmlNode &  b 
) [inline]

Definition at line 86 of file XmlNode.h.

References pcce::XmlNode::mElement.

00086                                                              {
00087     return a.mElement != b.mElement;
00088   }

ostream& pcce::operator<< ( ostream &  s,
const Vector4 &  v 
)

Definition at line 168 of file Vector4.cpp.

References pcce::Vector4::mValues.

00168                                                       {
00169   s << "Vector4("
00170     << v.mValues[0] << ", "
00171     << v.mValues[1] << ", "
00172     << v.mValues[2] << ", "
00173     << v.mValues[3] << ")";
00174   return s;
00175 }

ostream& pcce::operator<< ( ostream &  s,
const Vector3 &  v 
)

Definition at line 149 of file Vector3.cpp.

References pcce::Vector3::mValues.

00149                                                       {
00150   s << "Vector3("
00151     << v.mValues[0] << ", "
00152     << v.mValues[1] << ", "
00153     << v.mValues[2] << ")";
00154   return s;
00155 }

bool pcce::operator== ( const XmlNode &  a,
const void *  b 
) [inline]

Definition at line 90 of file XmlNode.h.

References pcce::XmlNode::mElement.

00090                                                           {
00091     return a.mElement == b;
00092   }

bool pcce::operator== ( const XmlNode &  a,
const XmlNode &  b 
) [inline]

Definition at line 82 of file XmlNode.h.

References pcce::XmlNode::mElement.

00082                                                              {
00083     return a.mElement == b.mElement;
00084   }

static unsigned short pcce::readByte16 ( const unsigned char  buffer[2]  )  [static]

Definition at line 182 of file soundutil.cpp.

Referenced by LoadWav().

00182                                                                   {
00183     #if PCCE_BIG_ENDIAN
00184     return (buffer[0] << 8) + buffer[1];
00185     #else
00186     return (buffer[1] << 8) + buffer[0];
00187     #endif
00188   }

static unsigned long pcce::readByte32 ( const unsigned char  buffer[4]  )  [static]

Definition at line 189 of file soundutil.cpp.

Referenced by LoadWav().

00189                                                                  {
00190     #if PCCE_BIG_ENDIAN
00191     return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
00192     #else
00193     return (buffer[3] << 24) + (buffer[2] << 16) + (buffer[1] << 8) + buffer[0];
00194     #endif
00195   }

tReal pcce::RoundTo ( const tReal &  x,
unsigned short  digits 
)

Definition at line 78 of file mathutil.cpp.

References IsInf(), IsNaN(), PCCE_CHECK, and Truncate().

00078                                                          {
00079   PCCE_CHECK(!IsNaN(x), "RoundTo: Cannot round NaN");
00080   PCCE_CHECK(!IsInf(x), "RoundTo: Cannot round Infinity");
00081 
00082   tReal div = std::pow(static_cast< tReal >(10.0), digits);
00083   return Truncate(x * div) / div;
00084 }

bool pcce::SameReal ( const tReal &  x,
const tReal &  y 
)

Definition at line 74 of file mathutil.cpp.

References CompareReal(), and crEqual.

Referenced by pcce::Vector4::Normalize(), pcce::Vector3::Normalize(), pcce::Vector4::operator==(), pcce::Vector3::operator==(), and pcce::Matrix4::operator==().

00074                                                   {
00075   return CompareReal(x, y) == crEqual;
00076 }

void pcce::SetActiveInputTranslator ( const tInputTranslatorPtr &  translator  ) 

Definition at line 124 of file InputTranslator.cpp.

References pcce::Singleton< T >::Get().

00124                                                                          {
00125   tIEventPtr event(new SetInputTranslatorEvent(translator));
00126   EventSystemSingleton::Get()->DispatchEvent(event);
00127 }

void pcce::ShutdownAL (  ) 

Shutdown OpenAL.

Definition at line 114 of file soundutil.cpp.

References ClearALError(), and PCCE_AL_CHECK.

Referenced by InitializeAL(), and pcce::SoundSubSystem::vShutdownThread().

00114                       {
00115   ClearALError();
00116   
00117   ALCcontext* context = alcGetCurrentContext();
00118   if (context == NULL) {
00119     PCCE_AL_CHECK();
00120     return;
00121   }
00122 
00123   ALCdevice* device = alcGetContextsDevice(context);
00124   PCCE_AL_CHECK();
00125 
00126   alcSuspendContext(context);
00127   PCCE_AL_CHECK();
00128   alcDestroyContext(context);
00129   PCCE_AL_CHECK();
00130   if (device != NULL) {
00131     alcCloseDevice(device);
00132     PCCE_AL_CHECK();
00133   }
00134 }

template<typename T>
tCompareResult pcce::Sign ( const T &  a  )  [inline]

Definition at line 72 of file mathutil.h.

References Compare().

Referenced by CompareReal().

00072                                                          {
00073     return Compare(a, static_cast< T >(0));
00074   }

void pcce::SleepMs ( tMillisecond  time  ) 

Cross-platform sleep function.

This function is a cross-platform way to sleep for at least the specified number of milliseconds. Note: It may sleep longer than the specified amount of time. The value is only a minimum.

Parameters:
time Minimum number of milliseconds to sleep

Definition at line 69 of file util.cpp.

References usPerMs.

Referenced by pcce::SoundSubSystem::vRunThread().

00069                                     {
00070 #ifdef WIN32
00071   Sleep(time);
00072 #else
00073   // This should really check the return value
00074   usleep(time * usPerMs);
00075 #endif
00076 }

tReal pcce::Truncate ( const tReal &  x  ) 

Definition at line 86 of file mathutil.cpp.

References IsInf(), IsNaN(), and PCCE_CHECK.

Referenced by RoundTo().

00086                                    {
00087   PCCE_CHECK(!IsNaN(x), "Truncate: Cannot truncate NaN");
00088   PCCE_CHECK(!IsInf(x), "Truncate: Cannot truncate Infinity");
00089   if (x < 0) {
00090     return std::ceil(x);
00091   } else {
00092     return std::floor(x);
00093   }
00094 }

Variable Documentation

const tHashValue pcce::AllEventsType = 0

Definition at line 44 of file EventDispatcherFwd.h.

Referenced by pcce::EventDispatcher::DispatchEvent(), pcce::EventDispatcher::DoCleanSignals(), pcce::EventDispatcher::EventDispatcher(), and pcce::EventSystem::EventSystem().

const tGameObjectID pcce::InvalidGameObjectID = 0

Definition at line 45 of file GameObject.h.

const std::string pcce::kMaterialNameProperty = "MaterialName"

Definition at line 79 of file GameObject.h.

Referenced by pcce::GameObject::GameObject(), pcce::GameObject::GetMaterialName(), pcce::GameObject::IsRenderReady(), and pcce::GameObject::SetMaterialName().

const std::string pcce::kPhysicsModelNameProperty = "PhysicsModelName"

Definition at line 81 of file GameObject.h.

Referenced by pcce::GameObject::GameObject(), pcce::GameObject::GetPhysicsModelName(), pcce::GameObject::IsPhysicsReady(), and pcce::GameObject::SetPhysicsModelName().

const std::string pcce::kRenderModelNameProperty = "RenderModelName"

Definition at line 80 of file GameObject.h.

Referenced by pcce::GameObject::GameObject(), pcce::GameObject::GetRenderModelName(), pcce::GameObject::IsRenderReady(), and pcce::GameObject::SetRenderModelName().

const tMillisecond pcce::msPerS = 1000

Definition at line 46 of file util.h.

Referenced by GetTimeSinceStart().

const tReal pcce::Pi = static_cast< tReal>(M_PI)

Definition at line 46 of file mathutil.h.

const tReal pcce::PiDiv2 = static_cast< tReal>(M_PI / 2)

Definition at line 48 of file mathutil.h.

const std::string pcce::SoundResourceType = "SoundResource"

Definition at line 41 of file SoundResource.h.

Referenced by pcce::Protocce::Initialize(), and pcce::SoundResource::vGetType().

const tReal pcce::TwoPi = static_cast< tReal>(2 * M_PI)

Definition at line 47 of file mathutil.h.

const tMillisecond pcce::usPerMs = 1000

Definition at line 47 of file util.h.

Referenced by GetTimeSinceStart(), and SleepMs().

Generated on Thu Mar 6 11:39:27 2008 for Protocce by  doxygen 1.5.5