burger.h File Reference

The master all inclusive header. More...

Include dependency graph for burger.h:

Classes
struct	Burger::longlong_t
struct	Burger::ulonglong_t
struct	Burger::Vector_128Float32
	Structure to create a 128 vector with 32 bit floating point constants. More...
struct	Burger::Vector_128Float64
	Structure to create a 128 vector with 64 bit floating point constants. More...
struct	Burger::Vector_128Int32
	Structure to create a 128 vector with 32 bit signed integer constants. More...
struct	Burger::Vector_128Word64
	Structure to create a 128 vector with 64 bit unsigned integer constants. More...
struct	Burger::Vector_128Word32
	Structure to create a 128 vector with 32 bit unsigned integer constants. More...
struct	Burger::Vector_128Word8
	Structure to create a 128 vector with 8 bit unsigned integer constants. More...
struct	Burger::Vector_128Word16
	Structure to create a 128 vector with 16 bit unsigned integer constants. More...
union	Burger::uint32_float_t
	Union to create float values with integer constants. More...
union	Burger::uint64_double_t
	Union to create double values with integer constants. More...
struct	Burger::type_traits::no_type
	Type used for templates to return 0. More...
struct	Burger::type_traits::size_type< T >
	Type used for templates the require a specific size. More...
struct	Burger::conditional< B, T, F >
	Select a type based if the conditional is true or false. More...
struct	Burger::enable_if< B, T >
	Create typedef type if condition is true. More...
struct	Burger::disable_if< B, T >
	Create typedef type if condition is false. More...
struct	Burger::integral_constant< T, _Value >
	Wrap a static constant of specified type. More...
struct	Burger::bool_constant< _Value >
	Wrap a static bool constant. More...
struct	Burger::alignment_of< T >
	Determine the alignment of an object. More...
struct	Burger::ice_and< p1, p2, p3, p4, p5, p6, p7 >
	Test for all values being true. More...
struct	Burger::ice_or< p1, p2, p3, p4, p5, p6, p7 >
	Test for any value being true. More...
struct	Burger::ice_eq< p1, p2 >
	Test for equality. More...
struct	Burger::ice_ne< p1, p2 >
	Test for inequality. More...
struct	Burger::ice_not< p >
	Reverse boolean input. More...
struct	Burger::is_same< T, U >
	Determine if two objects are the same type. More...
struct	Burger::remove_const< T >
	Remove the const qualifier from a type. More...
struct	Burger::remove_volatile< T >
	Remove the volatile qualifier from a type. More...
struct	Burger::remove_cv< T >
	Remove the volatile and const qualifier from a type. More...
struct	Burger::add_const< T >
	Add the const qualifier to a type. More...
struct	Burger::add_volatile< T >
	Add the volatile qualifier to a type. More...
struct	Burger::add_cv< T >
	Add the const and volatile qualifier to a type. More...
struct	Burger::remove_reference< T >
	Remove the reference qualifier to a type. More...
struct	Burger::is_const< T >
	Test if a type is const. More...
struct	Burger::is_volatile< T >
	Test if a type is volatile. More...
struct	Burger::is_void< T >
	Test if a type is void. More...
struct	Burger::is_integral< T >
	Test if a type is an integer. More...
struct	Burger::is_floating_point< T >
	Test if a type is a float. More...
struct	Burger::is_arithmetic< T >
	Test if a type is an integer or a floating point number. More...
struct	Burger::is_fundamental< T >
	Test if a type is arithmetic or void. More...
struct	Burger::is_pointer< T >
	Test if a type is a pointer. More...
struct	Burger::remove_pointer< T >
	Remove the reference qualifier to a type. More...
struct	Burger::is_lvalue_reference< T >
	Test if a type is an lvalue reference. More...
struct	Burger::is_rvalue_reference< T >
	Test if a type is an rvalue reference. More...
struct	Burger::is_reference< T >
	Test if a type is a reference. More...
struct	Burger::is_signed< T >
	Test if a type is a signed value. More...
struct	Burger::is_unsigned< T >
	Test if a type is an unsigned value. More...
struct	is_function< T >
struct	select_value< B, T, _True, _False >
struct	default_delete< T >
struct	default_delete_array< T >
struct	Burger::Assert_t
	Container structure for Assert support. More...
struct	_GUID
	Globally unique identifier structure. More...
struct	Burger::StaticRTTI
	Structure to handle simple Run Time Type Identification. More...
class	Burger::Base
	Base class for virtual destructor. More...
class	Burger::allocator< T >
	Implementation of std::allocator<> More...
struct	Burger::allocator< T >::rebind< U >
	Its member type other is the equivalent allocator type to allocate elements of type T More...
class	Burger::allocator< void >
	Implementation of std::allocator<void> More...
struct	Burger::allocator< void >::rebind
	Its member type other is the equivalent allocator type to allocate elements of type T More...
class	Burger::allocator< const void >
	Implementation of std::allocator<void> More...
struct	Burger::allocator< const void >::rebind
	Its member type other is the equivalent allocator type to allocate elements of type T More...
struct	Burger::AllocatorBase
	Base class for memory manager objects. More...
struct	Burger::MemoryManager
	Base class for memory managers. More...
class	Burger::GlobalMemoryManager
	Singleton class for global memory allocation. More...
class	Burger::AllocatorANSI
	ANSI Memory Manager object. More...
class	Burger::MemoryManagerANSI
	ANSI Memory Manager. More...
class	Burger::MemoryManagerGlobalANSI
	Global ANSI Memory Manager helper class. More...
class	Burger::CodePage
	Shared constants for code page handlers. More...
class	Burger::ISOLatin1
	Conversion routines to support the ISOLatin1 text encoding scheme. More...
class	Burger::MacRomanUS
	Conversion routines to support the MacRomanUS text encoding scheme. More...
class	Burger::Win1252
	Conversion routines to support the Win1252 text encoding scheme. More...
class	Burger::Win437
	Conversion routines to support the Win437 text encoding scheme. More...
class	Burger::Half
	Container for a 16 bit float. More...
class	Burger::FPInfo
	Class for analyzing a floating point number. More...
class	Burger::FPLargeInt
	Class for managing a very large integer for double precision. More...
class	Burger::FPPrintInfo
	Digit printing class for floating point. More...
struct	Burger::ThreadLocalStorageEntry_t
	Thread local storage for shutdown callback. More...
struct	Burger::ThreadLocalStorage_t
	Simple array of ThreadLocalStorageEntry_t records. More...
struct	Burger::ThreadLocalStorageRecord_t
	Internal record to match ThreadLocalStorage_t to a thread. More...
class	Burger::Thread
	Class for creating a thread. More...
class	Burger::Mutex
	Class for creating a Mutex for a critical section of data. More...
class	Burger::MutexStatic
	Class for creating a Mutex for a statically allocated critical section of data. More...
class	Burger::MutexLock
	Class for locking and releasing a mutex in a function. More...
class	Burger::Semaphore
	Class for creating a semaphore. More...
class	Burger::ConditionVariable
	Class for creating a condition variable. More...
struct	Burger::DoubleLinkedList_t
	Double linked list. More...
class	Burger::DoubleLinkedList
	Simple double linked list manager. More...
class	Burger::LinkedListPointer
	Double linked list with pointer class. More...
class	Burger::LinkedListObjects
	Linked list object class. More...
class	Burger::LinkedListObjects::Object
	Instance of a linked list object that contains a pointer to arbitrary data. More...
class	Burger::ForwardLink
	Singly linked list pointer. More...
class	Burger::LastInFirstOut
	Class that manages a last in first out singly linked list. More...
class	Burger::MPLastInFirstOut
	Thread safe class that manages a last in first out singly linked list. More...
class	Burger::RandomBase
	A random number generator base class. More...
class	Burger::Random
	A simple random number generator. More...
class	Burger::RandomMersenneTwist
	Random number generator using Mersenne Twist (MT19937) More...
struct	Burger::MD2_t
	16 byte array to contain an MD2 hash More...
struct	Burger::MD2Hasher_t
	Multi-pass MD2 hash generator. More...
struct	Burger::MD4_t
	16 byte array to contain an MD4 hash More...
struct	Burger::MD4Hasher_t
	Multi-pass MD4 hash generator. More...
struct	Burger::MD5_t
	16 byte array to contain an MD5 hash More...
struct	Burger::MD5Hasher_t
	Multi-pass MD5 hash generator. More...
struct	Burger::GOST_t
	32 byte array to contain a GOST hash More...
struct	Burger::GOSTHasher_t
	Multi-pass GOST hash generator. More...
struct	Burger::SHA1_t
	20 byte array to contain a SHA-1 hash More...
struct	Burger::SHA1Hasher_t
	Multi-pass SHA1 hash generator. More...
struct	Burger::NativeEndian
	Loads a 16, 32 or 64 bit value with no byte swapping. More...
struct	Burger::SwapEndian
	Swap the byte order of 16, 32 and 64 bit values. More...
struct	Burger::LittleEndian
	Loads a 16, 32 or 64 bit value with byte swapping if needed. More...
struct	Burger::BigEndian
	Loads a 16, 32 or 64 bit value with byte swapping if needed. More...
class	Burger::MemoryManagerHandle
	Handle based Memory Manager. More...
struct	Burger::MemoryManagerHandle::Handle_t
	Structure describing an allocated chunk of memory. More...
struct	Burger::MemoryManagerHandle::SystemBlock_t
class	Burger::AllocatorHandle
class	Burger::MemoryManagerGlobalHandle
	Global Handle Memory Manager helper class. More...
class	Burger::Localization
	Localization functions. More...
struct	Burger::MacOSXOld
	Functions exclusive to Apple macOS. More...
struct	Burger::default_delete_Base< T >
struct	Burger::default_delete_Free< T >
struct	Burger::unique_ptr< T, Deleter >
	Simplified implementation of std::unique_ptr. More...
struct	Burger::unique_ptr_array< T >
struct	Burger::unique_ptr_Base< T >
struct	Burger::unique_ptr_Free< T >
union	Burger::ArgumentTypeDataUnion_t
	Data stored in this object. More...
union	Burger::ArgumentType_t
	Base structure for ArgumentType. More...
struct	Burger::ArgumentType_Dispatch< T, size, bIsIntegral, bIsPointer >
	Intrinsic data type dispatcher. More...
struct	Burger::ArgumentType_DispatchPtr< T, size, bIsIntegral >
	Intrinsic data type dispatcher. More...
class	Burger::ArgumentType
	Container class for passing data to SafePrint. More...
class	Burger::CodeLibrary
	Manage code library files. More...
class	Burger::CodeFramework
	Manage MacOSX / iOS Framework library files. More...
struct	Burger::CPUID_t
	Structure that holds the features of the CPU. More...
struct	Burger::FourCharacterCode_t
	Helper structure to create 4 characters codes. More...
class	Burger::UTF8
	Conversion routines to support the UTF8 format. More...
class	Burger::UTF16
	Conversion routines to the UTF8 format. More...
class	Burger::UTF32
	Conversion routines to the UTF32 format. More...
class	Burger::SafePrint
	Container class for SafePrint functions. More...
struct	Burger::SafePrint::OutputTypeAndFlags_t
struct	Burger::SafePrint::ParamInfo_t
	Container struct for SafePrint arguments. More...
struct	Burger::SafePrint::ParamInfo_t::FloatDigitInfo_t
struct	Burger::SafePrint::ProcessResults_t
	struct to hold the results of parsing. More...
class	Burger::Queue< T >
	A simple first in first out queue. More...
struct	Burger::Queue< T >::Element
	A single data chunk in the queue. More...
class	Burger::ProxyReferenceCounter
	Class to track an object that can be deleted at any time. More...
class	Burger::ReferenceCounter
	Class to track an object using SmartPointer. More...
class	Burger::WeakPointerAnchor
	Private sub class for use by WeakPointer. More...
class	Burger::WeakAndStrongBase
	Base class to support WeakPointer and SmartPointer. More...
class	Burger::SmartPointer< T >
	Template for auto reference counting a pointer. More...
class	Burger::WeakPointer< T >
	Template for tracking an object that could self destruct. More...
class	Burger::Pair< T1, T2 >
	Template for creating an object pair. More...
class	Burger::SimpleArrayBase
	Base class for SimpleArray. More...
class	Burger::SimpleArray< T >
	Template for creating arrays of intrinsic objects. More...
class	Burger::ClassArray< T >
	Template for creating arrays of class objects. More...
class	Burger::String
	UTF 8 bit string class. More...
class	Burger::String16
	UTF 16 bit string class. More...
class	Burger::Uname
struct	Burger::Globals
	Global variables shared by all functions in the application. More...
class	Burger::HashMapShared
	Base class for HashMap. More...
class	Burger::HashMapShared::Entry
	Base data entry for HashMap. More...
class	Burger::HashMapShared::const_iterator
	STL compatible iterator base class. More...
class	Burger::HashMap< T, U >
	Key / data pair hash for quick lookup and retrieval. More...
class	Burger::HashMap< T, U >::Entry
	Key / data pair for HashMap. More...
class	Burger::HashMap< T, U >::const_iterator
	STL compatible constant iterator for HashMap. More...
class	Burger::HashMap< T, U >::iterator
	STL compatible iterator for HashMap. More...
class	Burger::HashMapString< U >
	String key / data pair hash for quick lookup and retrieval. More...
class	Burger::HashMapStringCase< U >
	String key / data pair hash for quick lookup and retrieval. More...
struct	Burger::Vector2D_t
	2 dimensional floating point vector More...
struct	Burger::Word32ToVector2D_t
	Structure to create a Vector2D_t with 32 bit unsigned integer constants. More...
struct	Burger::Vector3D_t
	3 dimensional floating point vector More...
struct	Burger::Word32ToVector3D_t
	Structure to create a Vector3D_t with 32 bit unsigned integer constants. More...
struct	Burger::Vector4D_t
	4 dimensional floating point vector More...
struct	Burger::FixedVector2D_t
	2 dimensional fixed point vector More...
struct	Burger::FixedVector3D_t
	3D Fixed32 vector. More...
struct	Burger::FixedVector4D_t
	4 dimensional fixed point vector More...
struct	Burger::Matrix3D_t
	3 dimensional floating point matrix More...
struct	Burger::Matrix4D_t
	4 dimensional floating point matrix More...
struct	Burger::FixedMatrix3D_t
	3 dimensional fixed point matrix More...
struct	Burger::FixedMatrix4D_t
	4x4 Fixed32 matrix. More...
class	Burger::NumberString
	Simple "C" string numeric conversion class. More...
class	Burger::NumberStringHex
	Simple "C" string hexadecimal conversion class. More...
class	Burger::SimpleString
	Simple "C" string container. More...
class	Burger::InputMemoryStream
	Fast input memory stream. More...
class	Burger::OutputMemoryStream
	Fast output memory stream. More...
struct	Burger::OutputMemoryStream::Chunk_t
	Data chunk for OutputMemoryStream. More...
class	Burger::CaptureStdout
	Class to capture stdout and stderr. More...
struct	Burger::TimeDate_t
	Structure to hold a date and time. More...
class	Burger::Tick
	Low level timer manager. More...
struct	Burger::Tick::Scaler_t
class	Burger::FloatTimer
	Floating point timer. More...
class	Burger::Filename
	File name container. More...
struct	Burger::Filename::ExpandCache_t
	Structure to contain a directory cache entry. More...
class	Burger::FileManager
	Global file system manager. More...
struct	Burger::FileManager::Queue_t
	Asynchronous file I/O message. More...
class	Burger::FileManagerSimple
	Initialization class for the global FileManager structure. More...
class	Burger::File
	System file reference class. More...
class	Burger::DirectoryEntry_t
	A directory entry returned by DirectorySearch. More...
class	Burger::DirectorySearch
	Directory contents iteration class. More...
class	Burger::AutoRepeat
	Autorepeat a joystick. More...
class	Burger::RunQueue
	Simple manager of a list of function pointers. More...
class	Burger::RunQueue::RunQueueEntry
	Function pointer entry. More...
class	Burger::DetectMultiLaunch
	Class to detect multiple launches of a desktop application. More...
class	Burger::OSCursorImage
	Class to generate an operating system cursor. More...
class	Burger::OSCursor
	Class to handle an operating system cursor. More...
struct	Burger::Point2D_t
	Integer 2D coordinate. More...
struct	Burger::Rect_t
	Structure describing an integer precision 2D rectangle. More...
class	Burger::Perforce
	Handle a connection to a perforce server. More...
class	Burger::ConsoleApp
	Base class for console applications. More...
class	Burger::Compress
	Base class for data compression. More...
class	Burger::CompressILBMRLE
	Compress data using ILBM Run Length Encoding. More...
class	Burger::CompressLZSS
	Compress data using LZSS encoding. More...
class	Burger::CompressDeflate
	Compress data using Deflate Encoding. More...
struct	Burger::CompressDeflate::CodeData_t
	Structure for each huffman tree entry. More...
struct	Burger::CompressDeflate::StaticTreeDesc_t
	Structure for each static huffman tree entry. More...
struct	Burger::CompressDeflate::TreeDesc_t
class	Burger::Decompress
	Base class for data decompression. More...
class	Burger::DecompressILBMRLE
	Decompress RLE format. More...
class	Burger::DecompressLZSS
	Decompress LZSS format. More...
class	Burger::DecompressDeflate
	Decompress Deflate format. More...
struct	Burger::DecompressDeflate::DeflateHuft_t
	Deflate huffman tree definition. More...
class	Burger::RezFile
	Rez file manager. More...
struct	Burger::RezFile::RootHeader_t
	Data image for the start of a Rez file. More...
struct	Burger::RezFile::FileRezEntry_t
	Data image of a resource entry. More...
struct	Burger::RezFile::FileRezGroup_t
	Data image of a resource group. More...
struct	Burger::RezFile::RezEntry_t
	Data to describe each individual resource in memory. More...
struct	Burger::RezFile::RezGroup_t
	Data to describe a group of resources in memory. More...
struct	Burger::RezFile::FilenameToRezNum_t
	Sorted list of filenames. More...
class	Burger::InputRezStream
	InputMemoryStream for RezFile. More...
struct	Burger::EventHeader_t
	Base structure for events. More...
struct	Burger::KeyEvent_t
	Structure holding a keyboard event. More...
struct	Burger::MouseButtonEvent_t
	Structure for mouse button events. More...
struct	Burger::MouseWheelEvent_t
	Structure for mouse wheel events. More...
struct	Burger::MouseMotionEvent_t
	Structure for mouse motion events. More...
struct	Burger::MousePositionEvent_t
	Structure for mouse position events. More...
struct	Burger::JoypadButtonEvent_t
	Structure for joypad button events. More...
class	Burger::GameApp
	Base class for video game application. More...
class	Burger::Renderer
	Base graphics renderer class. More...
class	Burger::RendererSoftware8
	8 bit paletted software renderer More...
class	Burger::RendererSoftware16
	16 bit software renderer More...
class	Burger::Image
	Class for containing raw images. More...
class	Burger::DisplayObject
	Class for managing display objects. More...
class	Burger::Texture
	Class for managing hardware images. More...
class	Burger::VertexBuffer
struct	Burger::VertexBuffer::VertexAoS_t
class	Burger::VertexBufferOpenGL
class	Burger::VertexBufferDirectX9
class	Burger::Effect
	Base class for shader effects. More...
class	Burger::Display
	Base class for instantiating a video display and the API to drive it. More...
struct	Burger::Display::VideoMode_t
	Description of a video card's video mode. More...
struct	Burger::Display::OpenGLVertexInputs_t
	Description of an OpenGL vertex input list. More...
struct	Burger::Display::OpenGLVertexBufferObjectDescription_t
	Description of an OpenGL vertex buffer object. More...
class	Burger::Display::VideoCardDescription
	Description of a video card's available video modes. More...
struct	Burger::Display::Globals_t
	Values to describe the default settings of the display. More...
class	Burger::DisplayOpenGL
class	Burger::DisplayOpenGLSoftware8
class	Burger::DisplayDirectX9
struct	Burger::DisplayDirectX9::DisplayMode_t
	Structure to describe a DirectX 9 display mode. More...
struct	Burger::DisplayDirectX9::DeviceSettings_t
	Structure to describe the state of a Direct3D9 device. More...
class	Burger::DisplayDirectX9::DeviceInfo
	Information for a GPU device. More...
class	Burger::DisplayDirectX9::AdapterInfo
	Information for a display device. More...
class	Burger::DisplayDirectX9::BufferFormatGroup
	Information for all pixel formats for a specific rendering device. More...
struct	Burger::DisplayDirectX9::BufferFormatGroup::MSQuality_t
	Structure to describe the maximum quality for a multisample type. More...
struct	Burger::DisplayDirectX9::BufferFormatGroup::DSMSConflict_t
	Structure to describe incompatible D3DFORMAT / D3DMULTISAMPLE_TYPE pairs. More...
class	Burger::DisplayDirectX9::Enumerator
	DirectX 9 device enumerator. More...
class	Burger::DisplayDirectX9Software8
class	Burger::DisplayDirectX11
struct	Burger::DisplayDirectX11::DXGISurfaceDesc_t
class	Burger::DisplayDIB
class	Burger::DisplayDIBSoftware8
	DIB startup and teardown class. More...
struct	Burger::RGBWord8_t
	Red, Green and Blue 8 bit values. More...
struct	Burger::RGBAWord8_t
	Red, Green,Blue and Alpha 8 bit values. More...
struct	Burger::RGBWord16_t
	Red, Green and Blue 16 bit values. More...
struct	Burger::RGBAWord16_t
	Red, Green,Blue and Alpha 16 bit values. More...
struct	Burger::RGBFloat_t
	Red, Green and Blue 32 bit floating point values. More...
struct	Burger::RGBAFloat_t
	Red, Green,Blue and Alpha 32 bit floating point values. More...
struct	Burger::HSL_t
	Hue, Saturation and Intensity 32 bit floating point values. More...
class	Burger::Palette
	Static functions to manage palettes. More...
struct	Burger::Palette::RGBColorList
struct	Burger::Dxt1Packet_t
	Data structure for a DXT1 compressed texture block. More...
struct	Burger::Dxt3Packet_t
	Data structure for a DXT3 compressed texture block. More...
struct	Burger::Dxt5Packet_t
	Data structure for a DXT5 compressed texture block. More...
class	Burger::TextureDirectX9
	Class for containing raw images. More...
class	Burger::TextureOpenGL
class	Burger::EffectPositionTexture
class	Burger::EffectPositionTextureDX9
class	Burger::EffectPositionTextureOpenGL
class	Burger::Effect2D
struct	Burger::Effect2D::Vertex
class	Burger::Effect2DDX9
class	Burger::Effect2DOpenGL
class	Burger::EffectPositionColorTexture
class	Burger::EffectPositionColorTextureDX9
class	Burger::EffectPositionColorTextureOpenGL
class	Burger::Shader2DColorVertex
struct	Burger::Shader2DColorVertex::Vertex
class	Burger::Shader2DColorVertexDX9
class	Burger::Shader2DColorVertexOpenGL
class	Burger::Shader2DCColor
struct	Burger::Shader2DCColor::Vertex
class	Burger::Shader2DCColorDX9
class	Burger::Shader2DCColorOpenGL
class	Burger::FileAPF
	Reads files. More...
class	Burger::FileBMP
	Reads and writes BMP files. More...
class	Burger::FileDDS
	Reads and writes DDS files. More...
class	Burger::GIFEncoder
	GIF style LZW compressor. More...
class	Burger::GIFDecoder
	GIF style LZW decompresser. More...
class	Burger::FileGIF
	Reads and writes GIF files. More...
class	Burger::FileINI
	Reads and writes INI files. More...
class	Burger::FileINI::Generic
	Base class for INI file line objects. More...
class	Burger::FileINI::Comment
	Untouched text object. More...
class	Burger::FileINI::Entry
	Key / Value pair. More...
class	Burger::FileINI::Section
	INI section chunk. More...
class	Burger::FileLBM
	Reads and writes LBM files. More...
class	Burger::FileMP3
	Reads and writes MP3 files. More...
struct	Burger::FileMP3::ID3V2Tag_t
class	Burger::FilePCX
	Reads and writes PCX files. More...
class	Burger::FilePNG
	Reads and writes PNG files. More...
class	Burger::FileTGA
	Reads and writes TGA files. More...
class	Burger::FileXML
	Reads and writes XML files. More...
class	Burger::FileXML::Generic
	Base class for XML file objects. More...
class	Burger::FileXML::Root
	Linked list root object. More...
class	Burger::FileXML::Comment
	Comment text object. More...
class	Burger::FileXML::CData
	Untouched text object intended for application parsing. More...
class	Burger::FileXML::Attribute
	XML Attribute key / value pair. More...
class	Burger::FileXML::Declaration
	XML Declaration object. More...
class	Burger::FileXML::RawText
	Raw text object. More...
class	Burger::FileXML::Element
	XML Element object. More...
struct	Burger::Shape8Bit_t
struct	Burger::Shape8BitOffset_t
struct	Burger::Shape8BitArray_t
struct	Burger::Shape8BitOffsetArray_t
struct	Burger::LWShape_t
struct	Burger::LWXShape_t
struct	Burger::GfxShape_t
class	Burger::Font
	Base class for font manager. More...
class	Burger::Font4Bit
	Class to render a tiny space 4 bit per pixel font. More...
struct	Burger::Font4Bit::State_t
struct	Burger::Font4Bit::RGBColorList_t
class	Burger::CommandParameter
	Base class for command line parameters. More...
class	Burger::CommandParameterBooleanTrue
	Class for a boolean command line parameters. More...
class	Burger::CommandParameterWordPtr
	Class for a numeric string command line parameter. More...
class	Burger::CommandParameterString
	Class for a string command line parameter. More...
class	Burger::Mouse
	Class for mouse input. More...
struct	Burger::Mouse::DeviceStruct
union	Burger::Mouse::MouseEvent_t
class	Burger::Keyboard
	Keyboard input manager. More...
struct	Burger::XInputGamePad_t
	Persistent state of an XInput gamepad. More...
class	Burger::Joypad
struct	Burger::Joypad::JoypadRange_t
	Range for each axis to convert analog data to digital data. More...
struct	Burger::Joypad::JoypadData_t
	Data record for each joypad. More...
class	Burger::SoundManager
class	Burger::SoundManager::SoundCardDescription
struct	Burger::SoundManager::BufferDescription_t
class	Burger::SoundManager::BufferDecoder
class	Burger::SoundManager::Buffer
	Audio data class. More...
class	Burger::SoundManager::Voice
	Audio playback class. More...
class	Burger::DecompressAudio
	Base class for audio decompression codec. More...
class	Burger::DecompressUnsigned8BitAudio
	Process unsigned 8 bit audio data. More...
class	Burger::DecompressSigned8BitAudio
	Process signed 8 bit audio data. More...
class	Burger::Decompress16BitBEAudio
	Process 16 bit audio data in Big Endian format. More...
class	Burger::Decompress16BitLEAudio
	Process 16 bit audio data in Little Endian format. More...
class	Burger::Decompress32BitBEAudio
	Process 32 bit audio data in Big Endian format. More...
class	Burger::Decompress32BitLEAudio
	Process 32 bit audio data in Little Endian format. More...
struct	Burger::MACEState_t
	State of MACE compression/decompression. More...
class	Burger::DecompressMace3
	Decompress MACE 3 format. More...
class	Burger::DecompressMace6
	Decompress MACE 6 format. More...
class	Burger::DecompressULaw
	Process audio data compressed with ULaw. More...
class	Burger::DecompressALaw
	Process audio data compressed with ALaw. More...
struct	Burger::ADPCMState_t
class	Burger::DecompressMicrosoftADPCM
	Decompress Microsoft ADPCM format. More...
class	Burger::DecompressMP3
	Process audio data compressed with MP3. More...
struct	Burger::DecompressMP3::FrameHeader_t
	Decoded 32 bit MP3 packet header. More...
struct	Burger::DecompressMP3::Layer2_AllocEntry_t
	Preset tables for Version 1, Layer 2 allocation entries. More...
struct	Burger::DecompressMP3::FrameHeaderExt_t
	Decoded 32 bit MP3 packet header with extended information. More...
struct	Burger::DecompressMP3::XingChunk_t
struct	Burger::DecompressMP3::GranuleInfo_t
struct	Burger::DecompressMP3::Chunk_t
struct	Burger::DecompressMP3::HuffmanCodeHeader_t
struct	Burger::DecompressMP3::Layer3Huffman_t
struct	Burger::DecompressMP3::BandInfo_t
struct	Burger::DecompressMP3::Layer3SideInfo_t
class	Burger::SoundBufferRez
	Convenience class for sound files in resources. More...
class	Burger::Sequencer
struct	Burger::Sequencer::Command_t
	A buffer describing a single note. More...
struct	Burger::Sequencer::PatternData_t
	A buffer describing a group of notes. More...
class	Burger::Sequencer::SampleDescription
	A buffer describing digital sample for an instrument. More...
struct	Burger::Sequencer::EnvelopeMarker_t
	A single entry for sound envelope marking. More...
struct	Burger::Sequencer::InstrData_t
struct	Burger::Sequencer::SongDescription_t
struct	Burger::Sequencer::Channel_t
class	Burger::Sequencer::SongPackage
struct	Burger::MacAddress_t
struct	Burger::NetAddr_t
	Generic structure to contain a network address. More...
struct	Burger::NetworkModuleInfo_t
	Structure to obtain information from a NetworkModule. More...
struct	Burger::NetPacket_t
class	Burger::NetworkManager
class	Burger::NetworkEndpointInstance
	Base class for network endpoint instances. More...
class	Burger::NetworkEndpoint
	Base class for network endpoints. More...
class	Burger::NetworkModuleSettings
	Abstract class for settings for endpoints. More...
struct	Burger::NetworkModuleSettings::LocatedServer_t
	Description of a located server. More...
struct	Burger::NetworkModuleSettings::EnumeratedServerInfo_t
	Information presented to the callback on a server to add or remove from the application's internal lists. More...
class	Burger::NetworkModule
struct	Burger::NetworkEnumPacketTCP_t
class	Burger::NetworkModuleSettingsTCP
class	Burger::NetworkModuleTCP
class	Burger::NetworkEndpointInstanceTCP
class	Burger::NetworkEndpointTCP
class	Burger::NetPlay
	Network game manager. More...
struct	Burger::NetPlay::PlayerInfo_t
struct	Burger::NetPlay::GroupInfo_t
struct	Burger::NetPlay::GameInfo_t
class	Burger::NetPlay::PlayerInfos
	Array of PlayerInfo_t structures. More...
class	Burger::NetPlay::GroupInfos
	Array of GroupInfo_t structures. More...
struct	Burger::NetPlay::MessageHeader_t
	Base header for a network packet. More...
struct	Burger::NetPlay::MessageJoinRequest_t
struct	Burger::NetPlay::MessageJoinApproved_t
struct	Burger::NetPlay::MessageJoinDenied_t
struct	Burger::NetPlay::MessagePlayerJoined_t
struct	Burger::NetPlay::MessagePlayerLeft_t
struct	Burger::NetPlay::MessageHostChanged_t
struct	Burger::NetPlay::MessageGameOver_t
struct	Burger::NetPlay::MessageGroupCreated_t
struct	Burger::NetPlay::MessageGroupDeleted_t
struct	Burger::NetPlay::MessagePlayerAddedToGroup_t
struct	Burger::NetPlay::MessagePlayerRemovedFromGroup_t
struct	Burger::NetPlay::MessagePlayerTypeChanged_t
struct	Burger::NetPlay::MessageJoinResponse_t
struct	Burger::NetPlay::MessageError_t
class	Burger::Steam
class	Burger::GridIndexPoints
	Manager to handle a grid with singly linked lists with values. More...
struct	Burger::GridIndexPoints::Entry_t
	Singly linked data chunk for GridIndexPoints. More...
struct	Burger::GridIndexPoints::iterator
	STL compatible iterator. More...
class	Burger::GridIndexBox
	Class for managing a grid with objects on overlapping areas. More...
struct	Burger::GridIndexBox::Entry
	Data chunk for GridIndexBox. More...
struct	Burger::GridIndexBox::iterator
	STL compatible iterator. More...
class	Burger::Flash::Stream
	Data stream manager for flash file parsing. More...
class	Burger::Flash::RGBAWord8
	RGBA color class for Flash. More...
class	Burger::Flash::Matrix23
	2x3 matrix for two dimensional rotations More...
class	Burger::Flash::Multiname
	Data packet for Flash Multiname support. More...
class	Burger::Flash::Namespace
	Data packet for Flash Multiname support. More...
class	Burger::Flash::BaseExecute
	Execution base class. More...
class	Burger::Flash::Rect
	Rectangle specialization for Adobe Flash. More...
class	Burger::Flash::ColorTransform
	Color transform for Adobe Flash. More...
class	Burger::Flash::SharedBuffer
	Shared data buffer. More...
class	Burger::Flash::Manager
	Manager to support the playing of Flash files. More...
class	Burger::Flash::ActionScriptProperty
	Shared data buffer. More...
class	Burger::Flash::ActionScriptValue
struct	Burger::Flash::OptionDetail_t
	Optional class parameters. More...
struct	Burger::Flash::ItemInfo_t
	Optional key/value pairs. More...
class	Burger::Flash::TraitsInfo
	Optional class traits. More...
struct	Burger::Flash::MetadataInfo
	Data to represent metadata_info. More...
class	Burger::Flash::ExceptionInfo
	Data to represent exception_info. More...
class	Burger::Flash::InstanceInfo
	Data to represent instance_info. More...
class	Burger::Flash::ClassInfo
	Data to represent class_info. More...
class	Burger::Flash::ScriptInfo
	Data to represent script_info. More...

Namespaces
namespace	Burger
namespace	Burger::type_traits
	Semi-private template classes for type checking.
namespace	Burger::Debug
	Group of functions to assist in debugging.
namespace	Burger::Vulkan
namespace	Burger::Flash
	Functions and classes to support playing Adobe Flash files.

Macros
#define	BURGER_NULL_MACRO_PARAM
	An empty macro parameter.
#define	BURGER_STRINGIZE2(x)
	Convert the parameter into a string literal.
#define	BURGER_STRINGIZE(x)
	Convert a macro into a string literal.
#define	BURGER_JOIN3(x, y)
	Combine two macros with ##.
#define	BURGER_JOIN2(x, y)
	Invokes BURGER_JOIN3.
#define	BURGER_JOIN(x, y)
	Concatenates two strings, even if they are macros.
#define	BURGER_LEFT_PARENTHESIS   (
	The character (.
#define	BURGER_RIGHT_PARENTHESIS   )
	The character )
#define	NULL   0
	Define of the number 0 for pointer invalidation.
#define	TRUE   1
	Define of the number 1 for boolean operations.
#define	FALSE   0
	Define of the number 0 for boolean operations.
#define	BURGER_CPP89   __cplusplus
	Define to determine if compiler has feature level C++89 (ANSI C)
#define	BURGER_CPP98   __cplusplus
	Define to determine if compiler has feature level C++98.
#define	BURGER_CPP11   __cplusplus
	Define to determine if compiler has feature level C++11.
#define	BURGER_CPP14   __cplusplus
	Define to determine if compiler has feature level C++14.
#define	BURGER_CPP17   __cplusplus
	Define to determine if compiler has feature level C++17.
#define	BURGER_CPP20   __cplusplus
	Define to determine if compiler has feature level C++20.
#define	BURGER_CPP23   __cplusplus
	Define to determine if compiler has feature level C++23.
#define	BURGER_STDCPP_NAME   "C++23"
	String of the C++ feature level.
#define	BURGER_HAS_64_BIT_SUPPORT
	Computer supports 64 bit integers.
#define	BURGER_HAS_SFINAE
	Compiler supports SFINAE.
#define	BURGER_INTEL
	Define to determine if the CPU is either X86 or AMD64.
#define	BURGER_PPC
	Define to determine if code is being built for PowerPC processors.
#define	BURGER_ARM
	Define to determine if code is being built for Advanced RISC Machine processors.
#define	BURGER_MIPS
	Define to determine if code is being built for MIPS processors.
#define	BURGER_SPARC
	Define to determine if code is being built for SPARC processors.
#define	BURGER_64BITCPU
	Define to determine if the CPU has 64 bit integer registers.
#define	BURGER_NEON
	Define to determine if code is being built for Advanced RISC Machines NEON instruction set extensions.
#define	BURGER_68881
	Define to determine if code is being built for Motorola 680x0 processor with a 68881 floating point unit.
#define	BURGER_ALTIVEC
	Define to determine if code is being built for PowerPC Altivec instruction set extensions.
#define	BURGER_SSE
	Define to determine if code is being built for SSE instruction set extensions.
#define	BURGER_SSE2
	Define to determine if code is being built for SSE2 instruction set extensions.
#define	BURGER_AVX
	Define to determine if code is being built for AVX instruction set extensions.
#define	BURGER_AVX2
	Define to determine if code is being built for AVX2 instruction set extensions.
#define	BURGER_WINDOWS
	Define to determine if code is being built for Microsoft 32 or 64 bit Windows.
#define	BURGER_MACOS
	Define to determine if code is being built for any Apple Mac OS platform.
#define	BURGER_DARWIN
	Define to determine if code is being built on a Darwin platorm.
#define	BURGER_UNIX
	Define to determine if code is being built on a unix platorm.
#define	BURGER_OPENGL
	Define for the presence of OpenGL.
#define	BURGER_OPENGLES
	Define for the presence of OpenGL ES.
#define	BURGER_VULKAN
	Define for the presence of Vulkan.
#define	BURGER_TCPIP
	Define for the presence of TCP/IP.
#define	BURGER_APPLETALK
	Define for the presence of AppleTalk.
#define	BURGER_IPX
	Define for the presence of IPX/SPX.
#define	BURGER_XBOXLIVE
	Define for the presence of Microsoft's Xbox Live platform.
#define	BURGER_CONSOLE
	Define for the presence of a text console.
#define	BURGER_BIGENDIAN
	Define to flag code running on a big endian machine.
#define	BURGER_ENDIANINDEX_LOW   1
	Index to the "low" word of a 64 bit value as a 32 value.
#define	BURGER_ENDIANINDEX_HIGH   (1 - BURGER_ENDIANINDEX_LOW)
	Index to the "high" word of a 64 bit value as a 32 value.
#define	__has_builtin(x)
	Clang feature macro for __has_builtin.
#define	__has_feature(x)
	Clang feature macro for __has_feature.
#define	__has_extension   __has_feature
	Clang feature macro for __has_extension.
#define	__has_cpp_attribute(x)
	Clang feature macro for __has_cpp_attribute.
#define	__has_declspec_attribute(x)
	Clang feature macro for __has_declspec_attribute.
#define	__has_attribute(x)
	Clang feature macro for __has_attribute.
#define	__has_warning(x)
	Clang feature macro for __has_warning.
#define	__has_include(x)
	Clang feature macro for __has_include.
#define	__has_include_next(x)
	Clang feature macro for __has_include_next.
#define	__GNUC_PREREQ(maj, min)
	GNUC version test macro.
#define	BURGER_API
	Default parameter passing type for Burgerlib functions.
#define	BURGER_ANSIAPI
	Default parameter passing type for ANSI library functions.
#define	BURGER_INLINE   inline
	Define to create inline code.
#define	BURGER_NO_INLINE
	Define to disable inline code.
#define	BURGER_NORETURN   [[noreturn]]
	Define to alert the compiler the function does not return.
#define	BURGER_PRINTF_ATTRIBUTE(_index, _check)
	Define to declare __attribute__((format)).
#define	BURGER_ASM   asm
	"C" compiler keyword for inline assembly.
#define	BURGER_DECLSPECNAKED   __declspec(naked)
	"C" compiler keyword for a pure assembly function.
#define	BURGER_68K_A0   :__A0
	Macro for register passing for 68K compilers.
#define	BURGER_68K_A1   :__A1
	Macro for register passing for 68K compilers.
#define	BURGER_68K_D0   :__D0
	Macro for register passing for 68K compilers.
#define	BURGER_68K_D1   :__D1
	Macro for register passing for 68K compilers.
#define	BURGER_ALIGN(__type, __name, __a)
	Macro to force data alignment.
#define	BURGER_PREALIGN(__a)
	First half of a macro to force data alignment.
#define	BURGER_POSTALIGN(__a)
	Second half of a macro to force data alignment.
#define	BURGER_STRUCT_PACKPUSH
#define	BURGER_STATIC_ASSERT(x)
	Test a compile time condition and if it's false, force a compiler error.
#define	BURGER_CONSTEXPR   constexpr
	Defined to nothing if constexpr is not supported.
#define	BURGER_NOEXCEPT   noexcept
	Defined to nothing if noexcept is not supported.
#define	BURGER_OVERRIDE   override
	Defined to nothing if the feature is not available.
#define	BURGER_FINAL   final
	Defined to nothing if the feature is not available.
#define	BURGER_EQUALS_DELETE   = delete
	Declare "= delete" on C++ 11 compilers.
#define	BURGER_EQUALS_DEFAULT   = default
	Declare "= default" on C++ 11 compilers.
#define	BURGER_DEFAULT_CONSTRUCTOR   BURGER_NOEXCEPT = default
	Declare "= default" on C++ 11 compilers.
#define	BURGER_DEFAULT_DESTRUCTOR   = default
	Declare "= default" on C++ 11 compilers.
#define	BURGER_RVALUE_REFERENCES
	Defined if move semantics are available.
#define	BURGER_ADDRESS_SANITIZER
	Detect if address sanitization is active.
#define	BURGER_DISABLE_ASAN   __attribute__((no_sanitize_address))
	Disable address sanitization.
#define	BURGER_MEMORY_SANITIZER
	Detect if memory sanitization is active.
#define	BURGER_DISABLE_MSAN   __attribute__((no_sanitize("memory")))
	Disable memory sanitization.
#define	BURGER_MAYBE_UNUSED   [[maybe_unused]]
	Mark with [[maybe_unused]].
#define	BURGER_NODISCARD   [[nodiscard]]
	Mark with [[nodiscard]].
#define	BURGER_FALLTHROUGH   [[fallthrough]]
	Mark with [[fallthrough]].
#define	BURGER_USED   __attribute__((used))
	Mark with attribute((used))
#define	BURGER_OFFSETOF(__type, __member)
	Define to return the offset of a member variable.
#define	BURGER_GET_BASE_PTR(x, __type, __member)
	Define to return the base pointer of a class from a class member.
#define	BURGER_CONST_GET_BASE_PTR(x, __type, __member)
	Define to return the const base pointer of a class from a class member.
#define	BURGER_UNUSED(x)
	Define to disable the unused variable warning.
#define	BURGER_ROUNDUP(__value, __alignment)
	Define to round up an integer to the next power of 2.
#define	BURGER_MSVC_SUPPRESS(__T)
	Invoke #pragma warning(suppress:) in Microsoft Compilers.
#define	BURGER_DISABLE_COPY(x)
	Declares copy constructors to disable invocation at runtime.
#define	BURGER_ENUM_TYPE(x, y)
	Creates a cross platform enum eSample : uint32_t { instance.
#define	BURGER_ENUM_CLASS_START(x, y)
	Creates a cross platform "enum class : int {" instance.
#define	BURGER_ENUM_CLASS_END(x)
	Finish a cross platform "enum class : int {" instance.
#define	BURGER_ENUM_MATH(x, y)
	Create math functions to handle an enum.
#define	BURGER_ENUM_CLASS_END_MATH(x, y)
	Finish a cross platform "enum class : int {" instance for flags.
#define	BURGER_SIZEOF_INT   4
	Size in bytes of the intrinsic int.
#define	BURGER_LONGLONG   Burger::longlong_t
	Signed 64 bit integer type specific to the current compiler.
#define	BURGER_ULONGLONG   Burger::ulonglong_t
	Unsigned 64 bit integer type specific to the current compiler.
#define	BURGER_SIZEOF_LONG   4
	Size in bytes of the intrinsic long.
#define	BURGER_LONG_NOT_IN_STDINT
	Is long used in stdint.h.
#define	BURGER_HAS_WCHAR_T
	Data type wchar_t is native.
#define	BURGER_HAS_CHAR8_T
	Data type char8_t is native.
#define	BURGER_HAS_CHAR16_T
	Data type char16_t and char32_t are native.
#define	BURGER_ARRAYSIZE(x)
	Define to return the number of elements in an array.
#define	BURGER_MININT   ((-0x7FFFFFFF) - 1)
	Minimum value of a signed integer.
#define	BURGER_MAXINT   0x7FFFFFFF
	Maximum value of a signed integer.
#define	BURGER_MAXUINT   0xFFFFFFFFU
	Maximum value of an unsigned integer.
#define	BURGER_MININT64   ((-0x7FFFFFFFFFFFFFFFLL) - 1)
	Minimum value of a int64_t.
#define	BURGER_MAXINT64   0x7FFFFFFFFFFFFFFFLL
	Maximum value of a int64_t.
#define	BURGER_MAXUINT64   0xFFFFFFFFFFFFFFFFULL
	Maximum value of a uint64_t.
#define	BURGER_MAXWORDPTR   UINTPTR_MAX
#define	BURGER_MAXINTPTR   INTPTR_MAX
	Maximum value of a signed address space integer.
#define	BURGER_MEMORYBARRIER()
	Invoke a memory barrier with the compiled code.
#define	BURGER_PAUSEOPCODE()
	Insert a yield instruction.
#define	BURGER_PI   (3.14159265358979323846264338328)
	Pi as a double.
#define	BURGER_SQRT2   (1.41421356237309504880168872421)
	sqrt(2.0) as a double
#define	BURGER_LN2   (0.69314718055994530941723212146)
	ln(2.0) as a double
#define	BURGER_LN10   (2.3025850929940456840179914547)
	ln(10.0) as a double
#define	BURGER_HALF_MIN   static_cast<float16_t>(0x0001U)
	Smallest value for a 16 bit float.
#define	BURGER_HALF_NRM_MIN   static_cast<float16_t>(0x0400U)
	Smallest normalized value for a 16 bit float.
#define	BURGER_HALF_MAX   static_cast<float16_t>(0x7BFFU)
	Largest value stored in a 16 bit float.
#define	BURGER_HALF_EPSILON   static_cast<float16_t>(0x1400U)
	Smallest positive difference between 16 bit float values.
#define	BURGER_HALF_POS_INF   static_cast<float16_t>(0x7C00U)
	16 bit float positive infinity
#define	BURGER_HALF_NEG_INF   static_cast<float16_t>(0xFC00U)
	16 bit float negative infinity
#define	BURGER_HALF_QNAN   static_cast<float16_t>(0x7FFFU)
	16 bit float QNAN
#define	BURGER_HALF_SNAN   static_cast<float16_t>(0x7DFFU)
	16 bit float SNAN
#define	BURGER_ASSERT(conditional)
	Invoke the debugger when a condition is met only when _DEBUG is defined.
#define	BURGER_ASSERTTEST(conditional)
	Always test a condition and if it's false, invoke the debugger.
#define	BURGER_RTTI_IN_CLASS()
	Macro for StaticRTTI support in a class.
#define	BURGER_RTTI_IN_BASE_CLASS()
	Macro for StaticRTTI support in a base class.
#define	BURGER_CREATE_STATICRTTI_BASE(__ClassName)
	Define to create a StaticRTTI for a base class.
#define	BURGER_CREATE_STATICRTTI_PARENT(__ClassName, __ParentClass)
	Define to create a StaticRTTI for a derived class.
#define	BURGER_STATICRTTI_ISTYPE(__ClassName, __Pointer)
	Return TRUE if the base class is also the requested class.
#define	BURGER_RTTICAST(__ClassName, __Pointer)
	Cast up a base class with verification.
#define	BURGER_RTTICONSTCAST(__ClassName, __Pointer)
	Cast up a const base class with verification.
#define	BURGER_LITTLEENDIAN16(x)
	Endian swaps a 16 bit constant on big endian machines.
#define	BURGER_LITTLEENDIAN32(x)
	Endian swaps a 32 bit constant on big endian machines.
#define	BURGER_BIGENDIAN16(x)
	Endian swaps a 16 bit constant on little endian machines.
#define	BURGER_BIGENDIAN32(x)
	Endian swaps a 32 bit constant on little endian machines.
#define	BURGER_FLOAT_TO_FIXED(x)
	Define to convert a float into a Fixed32.
#define	BURGER_FIXED_TO_FLOAT(x)
	Define to convert a Fixed32 into a float.
#define	BURGER_INT_TO_FIXED(x)
	Define to convert a integer into a Fixed32.
#define	BURGER_FIXED_TO_INT(x)
	Define to convert a Fixed32 value to an integer.
#define	BURGER_EXPAND_FORMATTING_FUNCTION(F)
	Function to generate SafePrint functions.
#define	BURGER_ALLOW_WEAK_POINTERS()
	Creates support for Burger::WeakPointer.
#define	MAKE_BURGER_STRING_FORMATTED_CONSTRUCTOR(N)
#define	MAKE_BURGER_STRING_PRINTF(N)
#define	MAKE_BURGER_STRING_PRINTF_STRREF(N)
#define	BURGER_VIRTUAL(a, b, c)
#define	BURGER_INVALID_SOCKET   UINTPTR_MAX

Typedefs
typedef int32_t	int2int_t
	int to int??_t.
typedef uint32_t	uint2uint_t
	unsigned int to uint??_t.
typedef int32_t	long2int_t
	long to int??_t.
typedef uint32_t	ulong2uint_t
	unsigned long to uint??_t.
typedef int8_t	Int8
	8 bit signed integer.
typedef uint8_t	Word8
	8 bit unsigned integer.
typedef int16_t	Int16
	16 bit signed integer.
typedef uint16_t	Word16
	16bit unsigned integer.
typedef int32_t	Int32
	32 bit signed integer.
typedef uint32_t	Word32
	32 bit unsigned integer.
typedef int64_t	Int64
	64 bit signed integer.
typedef uint64_t	Word64
	64 bit unsigned integer.
typedef unsigned int	uint_t
	Unsigned integer.
typedef signed int	int_t
	Signed integer.
typedef uint8_t	Bool
	Unsigned 8 bit integer for boolean operations.
typedef int32_t	Frac32
	Signed 32 bit integer for fixed point operations.
typedef int32_t	Fixed32
	Signed 32 bit integer for fixed point operations.
typedef unsigned int	Word
	Unsigned integer.
typedef signed int	Int
	Signed integer.
typedef uintptr_t	WordPtr
	Unsigned integer that matches in size to a void *.
typedef intptr_t	IntPtr
	Signed integer that matches in size to a void *.
typedef __m128	Vector_128
typedef uint8_t	Burger::Float80Bit[10]
	80 bit float(Extended)
typedef char	Burger::type_traits::yes_type
	Type used for templates to return 1.
typedef bool_constant< true >	Burger::true_type
	Static bool constant of true.
typedef bool_constant< false >	Burger::false_type
	Static bool constant of false.
typedef struct _GUID	GUID
	Globally unique identifier structure.
typedef uint16_t	Burger::float16_t
	16 bit float
typedef uintptr_t	Burger::ThreadID
	Platform Thread ID.
typedef void(*	Burger::TLSShutdownProc) (void *pThis)
	Callback prototype for TLS shutdown.
typedef uintptr_t	Burger::SocketType
	Cross platform type for a socket.
typedef uint_t(*	Burger::Flash::FSCommandProc) (CharacterObject *pMovie, const char *pCommand, const char *pArgs)
	Function prototype for user supplied FSCommand function.
typedef void(*	Burger::Flash::ActionScriptCFunctionProc) (const FunctionCallParms *pParms)
	Function prototype to implement an ActionScript command.
typedef DisplayDirectX9	Burger::DisplayDefault
typedef Effect2DDX9	Burger::Effect2DDefault
typedef EffectPositionColorTextureDX9	Burger::EffectPositionColorTextureDefault
typedef EffectPositionTextureDX9	Burger::EffectPositionTextureDefault
typedef Shader2DCColorDX9	Burger::Shader2DCColorDefault
typedef Shader2DColorVertexDX9	Burger::Shader2DColorVertexDefault
typedef VertexBufferDirectX9	Burger::VertexBufferDefault

Enumerations
enum	Burger::eError {   Burger::kErrorNone , Burger::kErrorGeneric = 0x7000 , Burger::kErrorInvalidParameter , Burger::kErrorInvalidArgument ,   Burger::kErrorNotInitialized , Burger::kErrorAlreadyInitialized , Burger::kErrorNotSupported , Burger::kErrorNotSupportedOnThisPlatform ,   Burger::kErrorVersionMismatch , Burger::kErrorItemNotFound , Burger::kErrorNotReady , Burger::kErrorOutOfEntries ,   Burger::kErrorOutOfBounds , Burger::kErrorFailedTest , Burger::kErrorDuplicateEntries , Burger::kErrorRestartRequired ,   Burger::kErrorFile = 0x7100 , Burger::kErrorFileNotFound , Burger::kErrorPathNotFound , Burger::kErrorVolumeNotFound ,   Burger::kErrorWriteProtected , Burger::kErrorNoMoreFileDescriptors , Burger::kErrorFileTableOverflow , Burger::kErrorDirectoryNotEmpty ,   Burger::kErrorNotAFile , Burger::kErrorNotADirectory , Burger::kErrorFileExists , Burger::kErrorOpenFailure ,   Burger::kErrorReadFailure , Burger::kErrorWriteFailure , Burger::kErrorSeekFailure , Burger::kErrorAccessDenied ,   Burger::kErrorResourceNotFound , Burger::kErrorIO , Burger::kErrorEndOfFile , Burger::kErrorIsLocked ,   Burger::kErrorMemory = 0x7200 , Burger::kErrorOutOfMemory , Burger::kErrorDataCorruption , Burger::kErrorBadAlignment ,   Burger::kErrorNoData , Burger::kErrorBufferTooSmall , Burger::kErrorBufferTooLarge , Burger::kErrorAudio = 0x7300 ,   Burger::kErrorAudioDriverFailure , Burger::kErrorAudioFormatNotSupported , Burger::kErrorNetwork = 0x7400 , Burger::kErrorCancelled ,   Burger::kErrorRefused , Burger::kErrorNetworkFailure , Burger::kErrorDataStarvation , Burger::kErrorSocketFailure ,   Burger::kErrorAcceptFailure , Burger::kErrorAddressNotFound , Burger::kErrorFlowInterrupted , Burger::kErrorVideo = 0x7500 ,   Burger::kErrorColorDepthNotSupported , Burger::kErrorResolutionNotSupported , Burger::kErrorGPUFailure , Burger::kErrorShaderCompile ,   Burger::kErrorShaderIncludeMissing , Burger::kErrorOutOfVideoMemory , Burger::kErrorPalette , Burger::kErrorThread = 0x7600 ,   Burger::kErrorTimeout , Burger::kErrorEnumerationInProgress , Burger::kErrorNotEnumerating , Burger::kErrorCantLock ,   Burger::kErrorCantUnlock , Burger::kErrorThreadNotStarted , Burger::kErrorThreadAlreadyStarted , Burger::kErrorThreadCantStop ,   Burger::kErrorThreadNotFound , Burger::kErrorThreadNotModified }
	Decompression error code. More...
enum	Burger::eThreadPriority {   Burger::kThreadPriorityInvalid , Burger::kThreadPriorityLow , Burger::kThreadPriorityNormal , Burger::kThreadPriorityHigh ,   Burger::kThreadPriorityRealTime }
	Thread priority setting. More...
enum	Burger::e8087Precision { Burger::k8087Precision24Bit = 0 , Burger::k8087PrecisionInvalid = 1 , Burger::k8087Precision56Bit = 2 , Burger::k8087Precision64Bit = 3 }
	32 bit Intel floating point precision More...
enum	Burger::e8087Rounding { Burger::k8087RoundingNearest = 0 , Burger::k8087RoundingDown = 1 , Burger::k8087RoundingUp = 2 , Burger::k8087RoundingTruncate = 3 }
	32 bit Intel floating point rounding mode More...
enum	Burger::ePowerPCRounding { Burger::kPPCRoundingNearest = 0 , Burger::kPPCRoundingTruncate = 1 , Burger::kPPCRoundingUp = 2 , Burger::kPPCRoundingDown = 3 }
	PowerPC floating point rounding mode. More...
enum	Burger::eArgumentType {   Burger::kArgumentTypeInvalid , Burger::kArgumentTypeInt8 , Burger::kArgumentTypeInt16 , Burger::kArgumentTypeInt32 ,   Burger::kArgumentTypeInt64 , Burger::kArgumentTypeUInt8 , Burger::kArgumentTypeUInt16 , Burger::kArgumentTypeUInt32 ,   Burger::kArgumentTypeUInt64 , Burger::kArgumentTypeFloat16 , Burger::kArgumentTypeFloat32 , Burger::kArgumentTypeFloat64 ,   Burger::kArgumentTypeBool , Burger::kArgumentTypeVector2 , Burger::kArgumentTypeVector4 , Burger::kArgumentTypeVector4Int ,   Burger::kArgumentTypeVector4Dbl , Burger::kArgumentTypeBurgerStringPtr , Burger::kArgumentTypeCharPtr , Burger::kArgumentTypeInt8Ptr ,   Burger::kArgumentTypeUInt8Ptr , Burger::kArgumentTypeInt16Ptr , Burger::kArgumentTypeUInt16Ptr , Burger::kArgumentTypeInt32Ptr ,   Burger::kArgumentTypeUInt32Ptr , Burger::kArgumentTypeInt64Ptr , Burger::kArgumentTypeUInt64Ptr , Burger::kArgumentTypeFloat32Ptr ,   Burger::kArgumentTypeFloat64Ptr , Burger::kArgumentTypeBoolPtr , Burger::kArgumentTypeVector2Ptr , Burger::kArgumentTypeVector4Ptr ,   Burger::kArgumentTypeVector4IntPtr , Burger::kArgumentTypeVector4DblPtr , Burger::kArgumentTypeVoidPtr , Burger::kArgumentTypeCount ,   Burger::kArgumentTypeAny , Burger::kArgumentTypeFirstInt = kArgumentTypeInt8 , Burger::kArgumentTypeLastInt = kArgumentTypeUInt64 , Burger::kArgumentTypeFirstSigned = kArgumentTypeInt8 ,   Burger::kArgumentTypeLastSigned = kArgumentTypeInt64 , Burger::kArgumentTypeFirstUnsigned = kArgumentTypeUInt8 , Burger::kArgumentTypeLastUnsigned = kArgumentTypeUInt64 , Burger::kArgumentTypeFirstFloat = kArgumentTypeFloat16 ,   Burger::kArgumentTypeLastFloat = kArgumentTypeFloat64 , Burger::kArgumentTypeFirstCString = kArgumentTypeBurgerStringPtr , Burger::kArgumentTypeLastCString = kArgumentTypeUInt8Ptr , Burger::kArgumentTypeFirstPointer = kArgumentTypeBurgerStringPtr ,   Burger::kArgumentTypeLastPointer = kArgumentTypeVoidPtr , Burger::kArgumentTypeFirstVector = kArgumentTypeVector2 , Burger::kArgumentTypeLastVector = kArgumentTypeVector4Dbl , Burger::kArgumentTypeFirstVectorPointer = kArgumentTypeVector2Ptr ,   Burger::kArgumentTypeLastVectorPointer = kArgumentTypeVector4DblPtr }
	Type stored in this object. More...
enum	Burger::eNumericConversionFlags : uint_t { Burger::NOENDINGNULL = 0x4000 , Burger::LEADINGZEROS = 0x8000 }
	Bit flags to control numeric text generation. More...
enum	Burger::eASCIITypeFlag : uint8_t {   Burger::ASCII_LOWER = 0x01 , Burger::ASCII_UPPER = 0x02 , Burger::ASCII_CONTROL = 0x04 , Burger::ASCII_SPACE = 0x08 ,   Burger::ASCII_WHITESPACE = 0x10 , Burger::ASCII_PUNCTUATION = 0x20 , Burger::kASCIITypeFlagHex = 0x40 , Burger::ASCII_DIGIT = 0x80 }
	Bit flags to quickly test low ASCII character type. More...
enum	Burger::eUnixFlavor {   Burger::kUnixUnknown , Burger::kUnixNative , Burger::kUnixMSYS2 , Burger::kUnixWSL ,   Burger::kUnixCygwin , Burger::kUnixMacOSX , Burger::kUnixiOS , Burger::kUnixAndroid ,   Burger::kUnixStadia }
	Enum describing the actual platform Unix is running on. More...
enum	Burger::eTraceFlags {   Burger::kTraceFlagMemoryLeak = 1 , Burger::kTraceFlagRezLoad = 2 , Burger::kTraceFlagFileLoad = 4 , Burger::kTraceFlagRaceWarnings = 8 ,   Burger::kTraceFlagNetwork = 0x10 , Burger::kTraceFlagMessages = 0x20 , Burger::kTraceFlagActiveDebugging = 0x40 , Burger::kTraceFlagAll = 0x7F }
	Flags to enable debugging features. More...
enum	Burger::eHintFlags { Burger::kHintWin32DisableThreadNamingException = 0x01 }
	Flags to enable/disable underlying code. More...
enum	{ Burger::kSleepYield = 0 , Burger::kSleepInfinite = 0xFFFFFFFFU }
enum	Burger::eEvent {   Burger::EVENT_NULL , Burger::EVENT_TIMER , Burger::EVENT_KEYDOWN , Burger::EVENT_KEYUP ,   Burger::EVENT_KEYAUTO , Burger::EVENT_MOUSEDOWN , Burger::EVENT_MOUSEUP , Burger::EVENT_MOUSEMOVE ,   Burger::EVENT_MOUSEPOSITION , Burger::EVENT_MOUSEWHEEL , Burger::EVENT_JOYPADDOWN , Burger::EVENT_JOYPADUP ,   Burger::EVENT_JOYPADAXIS , Burger::EVENT_COUNT }
	Enumeration for input events. More...
enum	Burger::eXInputDeadZoneType { Burger::XINPUTDEADZONE_NONE , Burger::XINPUTDEADZONE_CARDINAL , Burger::XINPUTDEADZONE_CENTER }
enum	Burger::eNetworkProtocol {   Burger::kNetworkProtocolAppleTalk , Burger::kNetworkProtocolIP , Burger::kNetworkProtocolIPX , Burger::kNetworkProtocolBonjour ,   Burger::kNetworkProtocolSteam , Burger::kNetworkProtocolXBoxLive , Burger::kNetworkProtocolUnknown , Burger::kNetworkProtocolCount }
	ID codes for supported Network protocols. More...
enum	Burger::eSocketIndexes { Burger::kSocketIndexDatagram , Burger::kSocketIndexStream , Burger::kSocketIndexCount }
	Number of types of sockets available. More...
enum	Burger::eSocketFlags { Burger::kSocketFlagDatagram , Burger::kSocketFlagStream = (1 << kSocketIndexStream) , Burger::kSocketFlagAll , Burger::kSocketFlagNone = 0 }
	Flags for socket types. More...
enum	Burger::Flash::eFileType {   Burger::Flash::UNKNOWN , Burger::Flash::SWF , Burger::Flash::JPG , Burger::Flash::X3DS ,   Burger::Flash::TXT , Burger::Flash::URL }
	Supported file type enumerations. More...
enum	Burger::Flash::eActionScriptStandardMember {   Burger::Flash::M_INVALID_MEMBER = -1 , Burger::Flash::M_X , Burger::Flash::M_Y , Burger::Flash::M_XSCALE ,   Burger::Flash::M_YSCALE , Burger::Flash::M_CURRENTFRAME , Burger::Flash::M_TOTALFRAMES , Burger::Flash::M_ALPHA ,   Burger::Flash::M_VISIBLE , Burger::Flash::M_WIDTH , Burger::Flash::M_HEIGHT , Burger::Flash::M_ROTATION ,   Burger::Flash::M_TARGET , Burger::Flash::M_FRAMESLOADED , Burger::Flash::M_NAME , Burger::Flash::M_DROPTARGET ,   Burger::Flash::M_URL , Burger::Flash::M_HIGHQUALITY , Burger::Flash::M_FOCUSRECT , Burger::Flash::M_SOUNDBUFTIME ,   Burger::Flash::M_XMOUSE , Burger::Flash::M_YMOUSE , Burger::Flash::M_PARENT , Burger::Flash::M_TEXT ,   Burger::Flash::M_TEXTWIDTH , Burger::Flash::M_TEXTCOLOR , Burger::Flash::M_BORDER , Burger::Flash::M_MULTILINE ,   Burger::Flash::M_WORDWRAP , Burger::Flash::M_TYPE , Burger::Flash::M_BACKGROUNDCOLOR , Burger::Flash::M_THIS ,   Burger::Flash::MTHIS , Burger::Flash::M_ROOT , Burger::Flash::MDOT , Burger::Flash::MDOT2 ,   Burger::Flash::M_LEVEL0 , Burger::Flash::M_GLOBAL , Burger::Flash::M_ENABLED , Burger::Flash::M_PASSWORD ,   Burger::Flash::M_MOUSE_MOVE , Burger::Flash::ACTION_SCRIPT_STANDARD_MEMBER_COUNT }
	Supported file type enumerations. More...

Functions
template<typename T , uintptr_t N>
const char(*	_BurgerArraySize (T(&)[N]))[N]
	Helper for BURGER_ARRAYSIZE.
void *	operator new (unsigned long, void *x) noexcept
template<class T >
constexpr remove_reference< T >::type &&	Burger::move (T &&t) noexcept
	Upconvert to && for move semantics.
template<typename T >
T *	round_up_pointer (T *pInput, uintptr_t uSize=alignment_of< T >::value) noexcept
template<class T >
void	swap_variables (T *pA, T *pB)
template<class T >
void	exchange (T &__A, T &__B)
template<typename T >
constexpr T	minimum (T A, T B) noexcept
template<typename T >
constexpr T	maximum (T A, T B) noexcept
const char *	Burger::error_lookup_string (eError uError) noexcept
	Convert a Burgerlib error code into a string.
uintptr_t	Burger::error_get_string (char *pOutput, uintptr_t uOutputSize, eError uError) noexcept
	Convert error code to a meaningful message.
eError	Burger::platform_convert_to_error (int iNativeError) noexcept
	Convert platform error code to a Burgerlib error code.
int	Burger::Assert (const char *pCondition, const char *pFilename, uint32_t uLineNumber) noexcept
	Redirect an assert to the application's assert function.
void	Burger::invoke_debugger (void) noexcept
	Enter the debugger if present.
void	Burger::GUID_init (GUID *pOutput) noexcept
	Create a new GUID.
void	Burger::GUID_to_string (char *pOutput, const GUID *pInput) noexcept
	Convert a GUID to a string.
eError	Burger::GUID_from_string (GUID *pOutput, const char *pInput) noexcept
	Convert a GUID string into a GUID.
uint_t	Burger::GUID_hash (const GUID *pInput) noexcept
	Return the 16 bit hash of a GUID.
uint_t	Burger::GUID_is_equal (const GUID *pInput1, const GUID *pInput2) noexcept
	Compare two GUID structures for equality.
int	Burger::GUID_compare (const GUID *pInput1, const GUID *pInput2) noexcept
	Test two GUID for equality.
void	Burger::Delete (const Base *pInput) noexcept
	Delete a base class.
uint32_t	Burger::power_of_two (uint32_t uInput) noexcept
	Round up an integer to the nearest power of 2.
uint64_t	Burger::power_of_two (uint64_t uInput) noexcept
	Round up an integer to the nearest power of 2.
float	Burger::power_of_two (float fInput) noexcept
	Round up a 32 bit float to the nearest power of 2.
double	Burger::power_of_two (double dInput) noexcept
	Round up a 64 bit float to the nearest power of 2.
template<class T >
T	Burger::power_of_two (T input) noexcept
	Round up an integer to the nearest power of 2.
uint32_t	Burger::convert_from_BCD (uint32_t uInput) noexcept
	Convert a BCD value into a decimal integer.
uint32_t	Burger::convert_to_BCD (uint32_t uInput) noexcept
	Convert a decimal integer into BCD format.
uint32_t	Burger::bit_reverse (uint32_t uInput, uint_t uBitLength) noexcept
	Reverse the bits in a byte.
uint64_t	Burger::bit_reverse (uint64_t uInput, uint_t uBitLength) noexcept
	Reverse the bits in a byte.
uint_t	Burger::count_set_bits (uint32_t uInput) noexcept
	Calculate the number of set bits.
uint_t	Burger::count_set_bits (uint64_t uInput) noexcept
	Calculate the number of set bits.
template<class T , class U >
bool	Burger::operator== (const allocator< T > &, const allocator< U > &) noexcept
	Allocators are always equal.
template<class T , class U >
bool	Burger::operator!= (const allocator< T > &, const allocator< U > &) noexcept
	Allocators are always equal.
void *	Burger::alloc_platform_memory (uintptr_t uSize) noexcept
	Allocate memory from the underlying operating system.
void	Burger::free_platform_memory (const void *pInput) noexcept
	Release memory back to the underlying operating system.
void *	Burger::Alloc (uintptr_t uSize) noexcept
	Allocate memory.
void	Burger::Free (const void *pInput) noexcept
	Release memory.
void *	Burger::Realloc (const void *pInput, uintptr_t uSize) noexcept
	Reallocate previously allocated memory.
void *	Burger::alloc_clear (uintptr_t uSize) noexcept
	Allocate memory that is preinitialized to zero.
void *	Burger::alloc_copy (const void *pInput, uintptr_t uSize) noexcept
	Allocate a buffer and copy data into it.
template<class T >
T *	Burger::New (void) noexcept
	Allocate a class instance.
template<class T >
void	Burger::Delete (const T *pInput) noexcept
	Dispose of a generic class instance.
uint32_t	Burger::translate_from_UTF8 (const char *pInput, const uint8_t pTranslateTable[128][4]) noexcept
	Translate a single UTF8 stream character into a mapped 8 bit char.
uintptr_t	Burger::translate_from_UTF8 (char *pOutput, uintptr_t uOutputSize, const char *pInput, const uint8_t pTranslateTable[128][4]) noexcept
	Convert a UTF8 stream into a ISOLatin1 "C" string.
uintptr_t	Burger::translate_from_UTF8 (char *pOutput, uintptr_t uOutputSize, const char *pInput, uintptr_t uInputSize, const uint8_t pTranslateTable[128][4]) noexcept
	Convert a UTF8 stream into a ISOLatin1 byte array.
float16_t	Burger::convert_to_float16 (float fInput) noexcept
	Convert a 32 bit float into a 16 bit float.
float	Burger::convert_to_float (float16_t uInput) noexcept
	Convert a 16 bit float into a 32 bit float.
void	Burger::separate_integer_fraction (FPLargeInt *pIntegerPart, FPLargeInt *pFractionalPart, const FPInfo *pFPInfo) noexcept
	Separate integer and fractional values from floating point number.
ThreadID	Burger::get_ThreadID (void) noexcept
	Return the ID of the current thread.
eThreadPriority	Burger::get_thread_priority (ThreadID uThreadID) noexcept
	Get the execution priority of a thread.
eError	Burger::set_thread_priority (ThreadID uThreadID, eThreadPriority uThreadPriority) noexcept
	Set the execution priority of a thread.
uint32_t	Burger::tls_new_index (void) noexcept
	Create a unique index for Thread Local Storage.
ThreadLocalStorage_t *	Burger::tls_data_get_fallback (void) noexcept
	Scan for Thread Local Storage (Private)
eError	Burger::tls_data_set_fallback (ThreadLocalStorage_t *pInput) noexcept
	Set a Thread Local Storage entry (Private)
ThreadLocalStorage_t *	Burger::tls_data_get (void) noexcept
	Get Thread Local Storage.
eError	Burger::tls_data_set (ThreadLocalStorage_t *pInput) noexcept
	Set a Thread Local Storage entry.
void *	Burger::tls_get (uint32_t uIndex) noexcept
	Get thread local storage for current thread.
eError	Burger::tls_set (uint32_t uIndex, const void *pThis, TLSShutdownProc pShutdown=nullptr) noexcept
	Set thread local storage for current thread.
void	Burger::tls_release (void) noexcept
	Release Thread Local Storage for current thread.
ForwardLink *	Burger::reverse_list (ForwardLink *pRoot) noexcept
	Reverse a singly linked list.
uint_t	Burger::calc_adler16 (const void *pInput, uintptr_t uInputLength, uint_t uAdler16=1) noexcept
	Compute the (Mark) Adler-16 checksum.
uint32_t	Burger::calc_adler32 (const void *pInput, uintptr_t uInputLength, uint32_t uAdler32=1) noexcept
	Compute the (Mark) Adler-32 checksum.
uint16_t	Burger::calc_crc16IBM (const void *pInput, uintptr_t uInputLength, uint16_t uCRC=0) noexcept
	Calculate the CRC16-IBM checksum (MP3) for a buffer.
void	Burger::generate_crc_table (uint16_t *pOutput, uint16_t uPolynomial=0x8005U, uint_t bBitReverse=1) noexcept
	Calculate a CRC16 polynomial table.
uint32_t	Burger::calc_crc32b (const void *pInput, uintptr_t uInputLength, uint32_t uCRC=0) noexcept
	Calculate the CRC32B checksum (ZLib) for a buffer.
uint32_t	Burger::calc_crc32 (const void *pInput, uintptr_t uInputLength, uint32_t uCRC=0) noexcept
	Calculate the CRC32 checksum (Ethernet) for a buffer.
void	Burger::generate_crc_table (uint32_t *pOutput, uint32_t uPolynomial=0x04C11DB7U, uint_t bBitReverse=1) noexcept
	Calculate a CRC32 polynomial table.
void	Burger::hash (MD2_t *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Quickly create an MD2 key.
void	Burger::hash (MD4_t *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Quickly create an MD4 key.
void	Burger::hash (MD5_t *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Quickly create an MD5 key.
void	Burger::hash (GOST_t *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Quickly create a GOST key.
void	Burger::generate_GOST_table (uint32_t *pOutput, const uint32_t pSBoxTable[8][16]=GOSTHasher_t::g_TestParmsSBox) noexcept
	Calculate a GOST polynomial table.
void	Burger::hash (SHA1_t *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Quickly create a SHA-1 key.
uintptr_t	Burger::SDBM_hash (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=0U) noexcept
	Hash data using the sdbm (Service Data Base Management) algorithm.
uintptr_t	Burger::SDBM_hash_case (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=0U) noexcept
	Hash string data using forced lower case with the sdbm (Service Data Base Management) algorithm.
uintptr_t	Burger::DJB2_hash_add (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=5381U) noexcept
	Hash data using the djb2 (Daniel Julius Bernstein) algorithm.
uintptr_t	Burger::DJB2_hash_add_case (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=5381U) noexcept
	Hash string data using forced lower case using the djb2 (Daniel Julius Bernstein) algorithm.
uintptr_t	Burger::DJB2_hash_xor (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=5381U) noexcept
	Hash data using the djb2 (Daniel Julius Bernstein) algorithm.
uintptr_t	Burger::DJB2_hash_xor_case (const void *pInput, uintptr_t uInputCount, uint32_t uHashSeed=5381U) noexcept
	Hash string data using forced lower case using the djb2 (Daniel Julius Bernstein) algorithm.
uint16_t	_swapendian16 (uint16_t uInput) noexcept
	Swap endian of a 16 bit integer.
uint32_t	_swapendian32 (uint32_t uInput) noexcept
	Swap endian of a 32 bit integer.
uint64_t	_swapendian64 (uint64_t uInput) noexcept
	Swap endian of a 64 bit integer.
void	_swapendianstore16 (void *pOutput, uint16_t uInput) noexcept
	Store a 16 bit value endian swapped.
void	_swapendianstore32 (void *pOutput, uint32_t uInput) noexcept
	Store a 32 bit value endian swapped.
void	_swapendianstore64 (void *pOutput, uint64_t uInput) noexcept
	Store a 64 bit value endian swapped.
uint64_t	_swapendian64ptr (const void *pInput) noexcept
	Load a 64 bit value endian swapped.
float	Burger::_swapendianfloat (float fInput) noexcept
	Swap endian of a 32 bit float.
double	Burger::_swapendiandouble (double dInput) noexcept
	Swap endian of a 64 bit float.
float	Burger::_swapendianfloat (const float *pInput) noexcept
	Swap endian of a 32 bit float from a pointer.
double	Burger::_swapendiandouble (const double *pInput) noexcept
	Swap endian of a 64 bit float.
uint16_t	Burger::_load_unaligned (const uint16_t *pInput) noexcept
	Fetch a 16 bit unsigned value from memory with byte alignment.
uint32_t	Burger::_load_unaligned (const uint32_t *pInput) noexcept
	Fetch a 32 bit unsigned value from memory with byte alignment.
uint64_t	Burger::_load_unaligned (const uint64_t *pInput) noexcept
	Fetch a 64 bit unsigned value from memory with byte alignment.
float	Burger::_load_unaligned (const float *pInput) noexcept
	Fetch a float value from memory with byte alignment.
double	Burger::_load_unaligned (const double *pInput) noexcept
	Fetch a double value from memory with byte alignment.
void	Burger::_store_unaligned (uint16_t *pOutput, uint16_t uInput) noexcept
	Store a 16 bit unsigned value to memory with byte alignment.
void	Burger::_store_unaligned (uint32_t *pOutput, uint32_t uInput) noexcept
	Store a 32 bit unsigned value to memory with byte alignment.
void	Burger::_store_unaligned (uint64_t *pOutput, uint64_t uInput) noexcept
	Store a 64 bit unsigned value to memory with byte alignment.
void	Burger::_store_unaligned (float *pOutput, float fInput) noexcept
	Store a float value to memory with byte alignment.
void	Burger::_store_unaligned (double *pOutput, double dInput) noexcept
	Store a double value to memory with byte alignment.
uint16_t	Burger::_load_unaligned_swap (const uint16_t *pInput) noexcept
	Fetch a 16 bit unsigned reverse endian integer from memory with byte alignment.
uint32_t	Burger::_load_unaligned_swap (const uint32_t *pInput) noexcept
	Fetch a 32 bit unsigned reverse endian integer from memory with byte alignment.
uint64_t	Burger::_load_unaligned_swap (const uint64_t *pInput) noexcept
	Fetch a 64 bit unsigned reverse endian integer from memory with byte alignment.
float	Burger::_load_unaligned_swap (const float *pInput) noexcept
	Fetch a 32 bit reverse endian float from memory with byte alignment.
double	Burger::_load_unaligned_swap (const double *pInput) noexcept
	Fetch a 64 bit reverse endian float from memory with byte alignment.
void	Burger::_store_unaligned_swap (uint16_t *pOutput, uint16_t uInput) noexcept
	Store a 16 bit unsigned value with endian swapping to memory with byte alignment.
void	Burger::_store_unaligned_swap (uint32_t *pOutput, uint32_t uInput) noexcept
	Store a 32 bit unsigned value with endian swapping to memory with byte alignment.
void	Burger::_store_unaligned_swap (uint64_t *pOutput, uint64_t uInput) noexcept
	Store a 64 bit unsigned value with endian swapping to memory with byte alignment.
void	Burger::_store_unaligned_swap (float *pOutput, float fInput) noexcept
	Store a float value to memory with endian swapping with byte alignment.
void	Burger::_store_unaligned_swap (double *pOutput, double dInput) noexcept
	Store a double value to memory with endian swapping with byte alignment.
void	Burger::swap_endian (uint16_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of an array of 16-bit integers.
void	Burger::swap_endian (uint16_t *pOutput, const uint16_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of a copied array of 16-bit integers.
void	Burger::swap_endian (uint32_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of an array of 32-bit integers.
void	Burger::swap_endian (uint32_t *pOutput, const uint32_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of a copied array of 32-bit integers.
void	Burger::swap_endian (uint64_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of an array of 64-bit integers.
void	Burger::swap_endian (uint64_t *pOutput, const uint64_t *pInput, uintptr_t uElements) noexcept
	Reverse the endian of a copied array of 64-bit integers.
void	Burger::swap_chars_to_bytes (void *pInput, uintptr_t uLength) noexcept
	Add 128 to every byte to convert a char to a byte or vice versa.
void	Burger::swap_chars_to_bytes (void *pOutput, const void *pInput, uintptr_t uLength) noexcept
	Add 128 to every byte to convert a char to a byte or vice versa.
e8087Precision	Burger::get_8087_precision (void) noexcept
	Get the floating point precision.
e8087Precision	Burger::set_8087_precision (e8087Precision uInput) noexcept
	Change the floating point precision.
e8087Rounding	Burger::get_8087_rounding (void) noexcept
	Get the floating point rounding setting.
e8087Rounding	Burger::set_8087_rounding (e8087Rounding uInput) noexcept
	Change the floating point precision.
uint32_t	Burger::set_mxcsr_flags (uint32_t uOrFlags, uint32_t uAndFlags) noexcept
	Change the SSE floating point precision.
ePowerPCRounding	Burger::get_PowerPC_rounding (void)
	Get the floating point rounding setting.
ePowerPCRounding	Burger::set_PowerPC_rounding (ePowerPCRounding uInput)
	Change the floating point precision.
float	Burger::get_sign (float fInput) noexcept
	Return sign constant.
double	Burger::get_sign (double dInput) noexcept
	Return sign constant.
constexpr float	Burger::square (float fInput) noexcept
	Return the square of the input.
constexpr double	Burger::square (double dInput) noexcept
	Return the square of the input.
float	Burger::absolute (float fInput) noexcept
	Get the absolute value of a float.
double	Burger::absolute (double dInput) noexcept
	Get the absolute value of a double.
float	Burger::square_root (float fInput) noexcept
	Get the square root value of a float.
double	Burger::square_root (double dInput) noexcept
	Get the square root value of a double.
constexpr float	Burger::int_to_float (int32_t iInput) noexcept
	32 bit integer to floating point conversion
float	Burger::int_to_float (const int32_t *pInput) noexcept
	32 bit integer to floating point conversion
void	Burger::int_to_float (float *pOutput, int32_t iInput) noexcept
	32 bit integer to floating point conversion
constexpr float	Burger::fixed_to_float (Fixed32 fInput) noexcept
	32 bit 16.16 fixed point integer to floating point conversion
float	Burger::fixed_to_float (const Fixed32 *pInput) noexcept
	32 bit 16.16 fixed point integer to floating point conversion
void	Burger::fixed_to_float (float *pOutput, Fixed32 fInput) noexcept
	32 bit 16.16 fixed point integer to floating point conversion
void	Burger::int_to_float (float *pOutput, const int32_t *pInput) noexcept
	32 bit integer to floating point conversion
void	Burger::fixed_to_float (float *pOutput, const Fixed32 *pInput) noexcept
	32 bit 16.16 fixed point integer to floating point conversion
constexpr float	Burger::interpolate (float fFrom, float fTo, float fFactor) noexcept
	Interpolate between two floating point values.
constexpr double	Burger::interpolate (double dFrom, double dTo, double dFactor) noexcept
	Interpolate between two floating point values.
template<typename T >
T	Burger::clamp (T Input, T Min, T Max) noexcept
	Clamp the input between a bounds.
uint_t	Burger::is_NaN (float fInput) noexcept
	Return TRUE if the value is a NaN.
uint_t	Burger::is_NaN (double dInput) noexcept
	Return TRUE if the value is a NaN.
uint_t	Burger::is_infinite (float fInput) noexcept
	Return TRUE if the value is infinity.
uint_t	Burger::is_infinite (double dInput) noexcept
	Return TRUE if the value is infinity.
uint_t	Burger::is_finite (float fInput) noexcept
	Return TRUE if the value is finite.
uint_t	Burger::is_finite (double dInput) noexcept
	Return TRUE if the value is finite.
uint_t	Burger::is_normal (float fInput) noexcept
	Return TRUE if the value is normal.
uint_t	Burger::is_normal (double dInput) noexcept
	Return TRUE if the value is normal.
uint_t	Burger::get_sign_bit (float fInput) noexcept
	Return TRUE if the value is negative.
uint_t	Burger::get_sign_bit (double dInput) noexcept
	Return TRUE if the value is negative.
uint_t	Burger::equal_with_epsilon (float fInput1, float fInput2) noexcept
	Return TRUE if the values are less than epsilon apart.
uint_t	Burger::equal_with_epsilon (double dInput1, double dInput2) noexcept
	Return TRUE if the values are less than epsilon apart.
uint_t	Burger::equal_with_epsilon (float fInput1, float fInput2, float fEpsilon) noexcept
	Return TRUE if the values are less than epsilon apart.
uint_t	Burger::equal_with_epsilon (double dInput1, double dInput2, double dEpsilon) noexcept
	Return TRUE if the values are less than epsilon apart.
float	Burger::get_floor (float fInput) noexcept
	Return a floating point number with the fraction removed.
double	Burger::get_floor (double dInput) noexcept
	Return a floating point number with the fraction removed.
float	Burger::get_ceiling (float fInput) noexcept
	Return a floating point number rounded up.
double	Burger::get_ceiling (double dInput) noexcept
	Return a floating point number rounded up.
float	Burger::get_round (float fInput) noexcept
	Return a floating point number rounded to the nearest integer.
double	Burger::get_round (double dInput) noexcept
	Return a floating point number rounded to the nearest integer.
float	Burger::round_to_zero (float fInput) noexcept
	Return a floating point number rounded to zero.
double	Burger::round_to_zero (double dInput) noexcept
	Return a floating point number rounded to zero.
float	Burger::modulo_radians (float fInput) noexcept
	Modulo the range of the input so that -BURGER_PI <= fInput < BURGER_PI.
double	Burger::modulo_radians (double dInput) noexcept
	Modulo the range of the input so that -BURGER_PI <= fInput < BURGER_PI.
float	Burger::sine_387 (float fInput) noexcept
	Return the sine from radians.
double	Burger::sine_387 (double fInput) noexcept
	Return the sine from radians.
float	Burger::cosine_387 (float fInput) noexcept
	Return the cosine from radians.
double	Burger::cosine_387 (double fInput) noexcept
	Return the cosine from radians.
float	Burger::get_sine_3_digits (float fInput) noexcept
	Return the sine from radians accurate to +-0.000597239.
float	Burger::get_cosine_3_digits (float fInput) noexcept
	Return the cosine from radians accurate to +-0.000597239.
float	Burger::get_sine_5_digits (float fInput) noexcept
	Return the sine from radians accurate to +-7.49199e-06.
float	Burger::get_cosine_5_digits (float fInput) noexcept
	Return the cosine from radians accurate to +- 7.49199e-06.
float	Burger::get_sine_6_digits (float fInput) noexcept
	Return the sine from radians accurate to +-1.03892e-06.
float	Burger::get_cosine_6_digits (float fInput) noexcept
	Return the cosine from radians accurate to +-1.1407e-06.
float	Burger::get_sine (float fInput) noexcept
	Return the sine from radians.
float	Burger::get_cosine (float fInput) noexcept
	Return the cosine from radians.
double	Burger::get_sine_7_digits (double dInput) noexcept
	Return the sine from radians accurate to +-2.05542e-06.
double	Burger::get_cosine_7_digits (double dInput) noexcept
	Return the cosine from radians accurate to +-2.05542e-06.
double	Burger::get_sine_12_digits (double dInput) noexcept
	Return the sine from radians accurate to +-7.48669e-13.
double	Burger::get_cosine_12_digits (double dInput) noexcept
	Return the cosine from radians accurate to +-7.48669e-13.
double	Burger::get_sine_18_digits (double dInput) noexcept
	Return the sine from radians.
double	Burger::get_cosine_18_digits (double dInput) noexcept
	Return the cosine from radians.
double	Burger::get_sine (double dInput) noexcept
	Return the sine from radians accurate to +-1.16573e-15.
double	Burger::get_cosine (double dInput) noexcept
	Return the cosine from radians accurate to +-1.34615e-15.
float	Burger::get_tangent (float fInput) noexcept
double	Burger::get_tangent (double dInput) noexcept
float	Burger::get_arcsine (float fInput) noexcept
double	Burger::get_arcsine (double dInput) noexcept
float	Burger::get_arccosine (float fInput) noexcept
double	Burger::get_arccosine (double dInput) noexcept
float	Burger::get_arctangent (float fInput) noexcept
double	Burger::get_arctangent (double dInput) noexcept
float	Burger::get_arctangent2 (float fSin, float fCos) noexcept
double	Burger::get_arctangent2 (double dSin, double dCos) noexcept
float	Burger::get_power (float fX, float fY) noexcept
double	Burger::get_power (double dX, double dY) noexcept
float	Burger::get_exponent (float fInput) noexcept
double	Burger::get_exponent (double dInput) noexcept
float	Burger::get_logarithm (float fInput) noexcept
double	Burger::get_logarithm (double dInput) noexcept
float	Burger::get_logarithm2 (float fInput) noexcept
double	Burger::get_logarithm2 (double dInput) noexcept
float	Burger::get_logarithm10 (float fInput) noexcept
double	Burger::get_logarithm10 (double dInput) noexcept
float	Burger::get_fraction (float fInput, float *pInteger) noexcept
double	Burger::get_fraction (double dInput, double *pInteger) noexcept
float	Burger::get_modulo (float fInput, float fDivisor) noexcept
double	Burger::get_modulo (double dInput, double dDivisor) noexcept
double	Burger::little_endian_load_extended (const Float80Bit pInput) noexcept
	Load a little endian 80 bit float as a double.
double	Burger::big_endian_load_extended (const Float80Bit pInput) noexcept
	Load a big endian 80 bit float as a double.
long	Burger::convert_to_DirectSound_volume (uint_t uInput) noexcept
	Convert a linear volume to decibels.
long	Burger::convert_to_DirectSound_volume (float fInput) noexcept
	Convert a linear volume to decibels.
long	Burger::convert_to_DirectSound_pan (uint_t uInput) noexcept
	Convert a linear pan to decibels.
long	Burger::convert_to_DirectSound_pan (float fInput) noexcept
	Convert a linear pan to decibels.
float	Burger::convert_to_AudioUnit_volume (uint_t uInput) noexcept
	Convert a linear volume to 0.0f to 1.0f.
float	Burger::convert_to_AudioUnit_pan (uint_t uInput) noexcept
	Convert a linear pan to 0.0f to 1.0f.
float	Burger::decibels_to_amplitude_ratio (float fDecibels) noexcept
	Convert a DirectSound decibel value to an XAudio2 Amplitude multiplier.
float	Burger::amplitude_ratio_to_decibels (float fVolume) noexcept
	Convert a XAudio2 Amplitude multiplier to a DirectSound decibel value.
uint_t	Burger::get_low_word (uint32_t uInput) noexcept
	Retrieves the low-order word from the specified value.
uint_t	Burger::get_high_word (uint32_t uInput) noexcept
	Retrieves the low-order word from the specified value.
Fixed32	Burger::int_to_fixed (int32_t iInput) noexcept
	Convert an int32_t into a Fixed32 value.
Fixed32	Burger::int_to_fixed_saturate (int32_t iInput) noexcept
	Convert an int32_t into a Fixed32 value with saturation.
int32_t	Burger::fixed_to_int_floor (Fixed32 fInput) noexcept
	Convert a fixed point value to an integer using round down.
int32_t	Burger::fixed_to_int (Fixed32 fInput) noexcept
	Convert a fixed point value to an integer using round to zero.
int32_t	Burger::fixed_to_int_ceil (Fixed32 fInput) noexcept
	Convert a fixed point value to an integer using round up.
int32_t	Burger::fixed_to_int_nearest (Fixed32 fInput) noexcept
	Convert a fixed point value to an integer using round to nearest.
int32_t	Burger::float_to_int_floor (float fInput) noexcept
	Convert a 32 bit float to an integer using floor().
void	Burger::float_to_int_floor (int32_t *pOutput, float fInput) noexcept
	Convert a 32 bit float to an integer using floor().
int32_t	Burger::float_to_int_ceil (float fInput) noexcept
	Convert a 32 bit float to an integer using ceil().
void	Burger::float_to_int_ceil (int32_t *pOutput, float fInput) noexcept
	Convert a 32 bit float to an integer using ceil().
int32_t	Burger::float_to_int_round (float fInput) noexcept
	Convert a 32 bit float to an integer using round to nearest.
void	Burger::float_to_int_round (int32_t *pOutput, float fInput) noexcept
	Convert a 32 bit float to an integer using round to nearest.
int32_t	Burger::float_to_int_round_to_zero (float fInput) noexcept
	Convert a 32 bit float to an integer using round to zero.
void	Burger::float_to_int_round_to_zero (int32_t *pOutput, float fInput) noexcept
	Convert a 32 bit float to an integer using round to zero.
Fixed32	Burger::float_to_fixed_floor (float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using floor().
void	Burger::float_to_fixed_floor (Fixed32 *pOutput, float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using floor().
Fixed32	Burger::float_to_fixed_ceil (float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using ceil().
void	Burger::float_to_fixed_ceil (Fixed32 *pOutput, float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using ceil().
Fixed32	Burger::float_to_fixed_round (float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using round to nearest.
void	Burger::float_to_fixed_round (Fixed32 *pOutput, float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using round to nearest.
Fixed32	Burger::float_to_fixed_round_to_zero (float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using round to zero.
void	Burger::float_to_fixed_round_to_zero (Fixed32 *pOutput, float fInput) noexcept
	Convert a 32 bit float to a Fixed32 using round to zero.
int8_t	Burger::absolute (int8_t iInput)
	Get the absolute value of an integer.
int16_t	Burger::absolute (int16_t iInput) noexcept
	Get the absolute value of an integer.
int32_t	Burger::absolute (int32_t iInput) noexcept
	Get the absolute value of an integer.
int64_t	Burger::absolute (int64_t iInput) noexcept
	Get the absolute value of a 64 bit integer.
int8_t	Burger::ClampZero (int8_t iInput) noexcept
	Clamp an integer to 0.
int16_t	Burger::ClampZero (int16_t iInput) noexcept
	Clamp an integer to 0.
int32_t	Burger::ClampZero (int32_t iInput) noexcept
	Clamp an integer to 0.
int64_t	Burger::ClampZero (int64_t iInput) noexcept
	Clamp an integer to 0.
constexpr int8_t	Burger::get_sign (int8_t iInput) noexcept
	Get the sign value of an integer.
constexpr int16_t	Burger::get_sign (int16_t iInput) noexcept
	Get the sign value of an integer.
constexpr int32_t	Burger::get_sign (int32_t iInput) noexcept
	Get the sign value of an integer.
constexpr int64_t	Burger::get_sign (int64_t iInput) noexcept
	Get the sign value of a 64 bit integer.
Fixed32	Burger::FixedMultiply (Fixed32 fInput1, Fixed32 fInput2)
	Multiply two 16.16 fixed point numbers.
Fixed32	Burger::FixedDivide (Fixed32 fInputNumerator, Fixed32 fInputDenominator)
	Divide two 16.16 fixed point numbers.
Fixed32	Burger::FixedReciprocal (Fixed32 fInput)
	Return the reciprocal of a fixed point number.
uint32_t	Burger::square_root (uint32_t uInput)
	Get the square root of an integer.
uint32_t	Burger::SqrtFixedToWord32 (Fixed32 fInput)
	Get the square root of a Fixed32.
Fixed32	Burger::square_root (Fixed32 uInput)
	Get the square root of a Fixed32.
uint32_t	Burger::RotateLeft (uint32_t uInput, uint_t uShiftCount) noexcept
	Rotate the bits left.
uint32_t	Burger::RotateRight (uint32_t uInput, uint_t uShiftCount) noexcept
	Rotate the bits right.
uint64_t	Burger::RotateLeft (uint64_t uInput, uint_t uShiftCount) noexcept
	Rotate the bits left.
uint64_t	Burger::RotateRight (uint64_t uInput, uint_t uShiftCount) noexcept
	Rotate the bits right.
void	Burger::MemoryCopy (void *pOutput, const void *pInput, uintptr_t uCount) noexcept
	Copy raw memory from one buffer to another.
void	Burger::MemoryMove (void *pOutput, const void *pInput, uintptr_t uCount) noexcept
	Copy raw memory from one buffer to another in any direction.
void	Burger::MemoryClear (void *pOutput, uintptr_t uCount) noexcept
	Set a buffer to all zeros.
void	Burger::MemoryFill (void *pOutput, uint8_t uFill, uintptr_t uCount) noexcept
	Set a buffer to a specific value.
void	Burger::MemoryNot (void *pOutput, uintptr_t uCount) noexcept
	Exclusive or a buffer with 0xFF.
void	Burger::MemoryNot (void *pOutput, const void *pInput, uintptr_t uCount) noexcept
	Copy a buffer that's been exclusive or'd with 0xFF.
void	Burger::MemoryXor (void *pOutput, uint8_t uXor, uintptr_t uCount) noexcept
	Exclusive or a buffer with a value.
void	Burger::MemoryXor (void *pOutput, const void *pInput, uint8_t uXor, uintptr_t uCount) noexcept
	Exclusive or a buffer with a value and store the result in another buffer.
void	Burger::MemoryXor (void *pOutput, const void *pInput, uintptr_t uCount) noexcept
	Exclusive or a buffer with another buffer.
void	Burger::MemoryXor (void *pOutput, const void *pInput1, const void *pInput2, uintptr_t uCount) noexcept
	Exclusive or a buffer with another buffer and store the result in a third buffer.
int	Burger::MemoryCompare (const void *pInput1, const void *pInput2, uintptr_t uCount) noexcept
	Compare two byte buffers for equality.
int	Burger::MemoryCaseCompare (const void *pInput1, const void *pInput2, uintptr_t uCount) noexcept
	Compare two byte buffers for equality, case insensitive.
char *	Burger::MemoryCharacter (const char *pInput, uintptr_t uInputSize, int iChar) noexcept
	Scan for the first occurrence of a specific character in a byte array.
uint16_t *	Burger::MemoryCharacter (const uint16_t *pInput, uintptr_t uInputSize, uint_t uChar) noexcept
	Scan for the first occurrence of a specific character in a short array.
char *	Burger::MemoryCharacterReverse (const char *pInput, uintptr_t uInputSize, int iChar) noexcept
	Scan for the last occurrence of a specific character in a buffer.
uint16_t *	Burger::MemoryCharacterReverse (const uint16_t *pInput, uintptr_t uInputSize, uint_t uChar) noexcept
	Scan for the last occurrence of a specific character in a uint16_t buffer.
uint_t	Burger::Debug::Fatal (const char *pMessage,...) noexcept
	A fatal error has occurred, print message, then exit.
void	Burger::Debug::Warning (const char *pMessage,...) noexcept
	Store a non-fatal error message, then return or exit.
void	Burger::Debug::Message (const char *pMessage,...) noexcept
	Print a message to the debugger output stream.
void	Burger::Debug::PrintString (const char *pMessage) noexcept
	Print a string to a file or debugger.
void	Burger::Debug::PrintString (uint32_t uInput) noexcept
	Print a uint32_t to the debug port.
void	Burger::Debug::PrintString (uint64_t uInput) noexcept
	Print a uint64_t to the debug port.
void	Burger::Debug::PrintErrorMessage (uint_t uErrorCode) noexcept
	Print the error message for an OS error code.
void	Burger::OkAlertMessage (const char *pMessage, const char *pTitle=nullptr) noexcept
	Display a dialog box.
uint_t	Burger::OkCancelAlertMessage (const char *pMessage, const char *pTitle=nullptr) noexcept
	Display a dialog to alert the user of a possible error condition or message.
uint_t	Burger::is_debugger_present (void) noexcept
	Detect if a debugger is attached.
uint_t	Burger::is_macsbug_installed (void) noexcept
	Test if macsbug is installed.
uint_t	Burger::is_metronub_installed (void) noexcept
	Test if Metrowerks Metronub is installed.
void	Burger::InitFileInfo (FileInfo *pFileInfo) noexcept
	Initialize a Mac Finder FileInfo.
void	Burger::InitFSRefParam (FSRefParam *pFSRefParam, FSRef *pFSRef, uint32_t uCatInfoBitmap) noexcept
	Initialize a Mac FSRefParam.
int	Burger::GetFilenameFromPathname (uint8_t *pOutput, const uint8_t *pInput) noexcept
	Extract a filename at the end of a MacOS path.
int	Burger::GetFileLocation (short *pVRefNum, long *pDirID, uint8_t *pOutputFilename, short iFileRefNum) noexcept
	Find a file location from a file reference number.
int	Burger::GetFileLocation (FSSpec *pOutput, short iFileRefNum) noexcept
	Find the FSSpec from a file reference number.
int	Burger::GetFileLocation (FSRef *pOutput, short iFileRefNum) noexcept
	Use an open file reference to return the FSRef.
int	Burger::CreateEmptyFile (short svRefNum, long lDirID, const uint8_t *pFilename) noexcept
	Call PBHCreateSync() to create a file.
int	Burger::CreateEmptyFile (const FSSpec *pFSSpec) noexcept
	Call FSpCreate() to create a file.
int	Burger::CreateEmptyFile (FSRef *pOutput, const FSRef *pFSSpec, const char *pName) noexcept
	Call PBCreateFileUnicodeSync() to create a file.
int	Burger::CheckForForks (short svRefNum, long lDirID, const uint8_t *pName, uint_t *pbDataFork, uint_t *pbResourceFork) noexcept
	Test if a file has either a resource or data fork.
int	Burger::CheckForForks (const FSSpec *pFSSpec, uint_t *pbDataFork, uint_t *pbResourceFork) noexcept
	Test if a file has either a resource or data fork.
int	Burger::CheckForForks (const FSRef *pFSRef, uint_t *pbDataFork, uint_t *pbResourceFork) noexcept
	Test if a file has either a resource or data fork.
int	Burger::DoCopyFile (short svRefNumDest, long lDirIDDest, const uint8_t *pFilenameDest, short svRefNumSource, long lDirIDSource, const uint8_t *pFilenameSource) noexcept
	Copy a file using PBHCopyFileSync()
int	Burger::DoCopyFile (const FSSpec *pFSDest, const FSSpec *pFSSource) noexcept
	Copy a file using PBHCopyFileSync()
int	Burger::CopyForkClassic (short iDestRefNum, short iSourceRefNum, uint8_t *pBuffer, uintptr_t uBufferSize) noexcept
	Copy a fork of a file using FSSpec APIs.
int	Burger::CopyForkCarbon (short iDestRefNum, short iSourceRefNum, uint8_t *pBuffer, uintptr_t uBufferSize) noexcept
	Copy a fork of a file using FSRef APIs.
int	Burger::CopyFileMgrAttributes (short svRefNumDest, long lDirIDDest, const uint8_t *pFilenameDest, short svRefNumSource, long lDirIDSource, const uint8_t *pFilenameSource, uint_t bCopyLockBit=1) noexcept
	Copy file manager metadata from one file to another.
int	Burger::CopyFileMgrAttributes (const FSSpec *pDestSpec, const FSSpec *pSourceSpec, uint_t bCopyLockBit=1) noexcept
	Copy file manager metadata from one file to another.
int	Burger::CopyFileMgrAttributes (const FSRef *pDestRef, const FSRef *pSourceRef, uint_t bCopyLockBit=1) noexcept
	Copy file manager metadata from one file to another.
int	Burger::DoPBXGetVolInfoSync (XVolumeParam *pXVolumeParam) noexcept
	Call PBXGetVolInfoSync() on all targets.
int	Burger::GetVolumeInfo (HParamBlockRec *pOutput, short sVRefNum) noexcept
	Obtain information about a volume.
int	Burger::GetVolumeInfo (XVolumeParam *pOutput, short svRefNum) noexcept
	Obtain information about an extended volume.
int	Burger::DetermineVRefNum (short *pOutput, short svRefNum) noexcept
	Find the real volume reference number.
int	Burger::CheckVolLock (short svRefNum) noexcept
	Check if a volume is locked.
int	Burger::DoGetCatInfo (CInfoPBRec *pOutput, uint8_t pOutputName[256], short sVRefNum, long lDirID, const uint8_t *pName) noexcept
	Call PBGetCatInfoSync() quickly.
int	Burger::DoGetCatInfo (CInfoPBRec *pOutput, uint8_t pOutputName[256], const FSSpec *pFSSpec) noexcept
	Call PBGetCatInfoSync() quickly.
int	Burger::DoGetCatInfo (FSCatalogInfo *pOutput, FSRefParam *pRefParam, const FSRef *pFSRef, uint32_t uCatInfoBitmap) noexcept
	Call PBGetCatalogInfoSync() quickly.
int	Burger::DoGetCatInfo (CInfoPBRec *pOutput, short sVRefNum, long lDirID, const uint8_t *pName) noexcept
	Call PBGetCatInfoSync() quickly.
int	Burger::DoGetCatInfo (CInfoPBRec *pOutput, const FSSpec *pFSSpec) noexcept
	Call PBGetCatInfoSync() quickly.
int	Burger::DoGetCatInfo (FSCatalogInfo *pOutput, const FSRef *pFSRef, uint32_t uCatInfoBitmap) noexcept
	Call PBGetCatalogInfoSync() quickly.
int	Burger::GetDirectoryInfo (DInfo *pFinderInfo, short sVRefNum, long lDirID, const uint8_t *pName) noexcept
	Get Finder DInfo for a directory.
int	Burger::GetDirectoryInfo (DInfo *pFinderInfo, const FSSpec *pFSSpec) noexcept
	Get Finder DInfo for a directory using a FSSpec.
int	Burger::GetDirectoryInfo (DInfo *pFinderInfo, const FSRef *pFSRef) noexcept
	Get Finder DInfo for a directory using a FSRef.
int	Burger::GetDestinationDirectoryInfo (short sVRefNum, long lDirID, const uint8_t *pName, long *pDirID, uint_t *pbDirectory, uint_t *pbDropBox) noexcept
	Get common information from a directory.
int	Burger::GetDestinationDirectoryInfo (const FSSpec *pFSSpec, long *pDirID, uint_t *pbDirectory, uint_t *pbDropBox) noexcept
	Get common information from a directory.
int	Burger::GetDestinationDirectoryInfo (const FSRef *pFSRef, long *pDirID, uint_t *pbDirectory, uint_t *pbDropBox) noexcept
	Get common information from a directory.
int	Burger::GetCommentID (short *pCommentID, short sVRefNum, long lDirID, const uint8_t *pName) noexcept
	Get finder comment ID.
int	Burger::GetCommentID (short *pCommentID, const FSSpec *pFSSpec) noexcept
	Get finder comment ID.
int	Burger::GetCommentID (short *pCommentID, const FSRef *pFSRef) noexcept
	Get finder comment ID.
int	Burger::GetDirectoryID (short sVRefNum, long lDirID, const uint8_t *pName, long *pDirID, uint_t *pbDirectory) noexcept
	Get directory ID of a named directory.
int	Burger::GetDirectoryID (const FSSpec *pFSSpec, long *pDirID, uint_t *pbDirectory) noexcept
	Get directory ID of a named directory.
int	Burger::GetDesktopFileName (uint8_t *pDesktopName, short svRefNum) noexcept
	Determine the name of the Finder Desktop Database.
int	Burger::GetCommentFromDesktopFile (char *pComment, short svRefNum, long lDirID, const uint8_t *pFileName) noexcept
	Load in a comment from a Desktop resource file.
int	Burger::DesktopOpen (const uint8_t *pVolumeName, short vRefNum, short *pRefNum, uint_t *pbDatabaseCreated) noexcept
	Open the desktop manager database.
int	Burger::DesktopGetComment (char *pOutput, short svRefNum, long lDirID, const uint8_t *pFilename) noexcept
	Get a comment from the Desktop Manager.
int	Burger::DesktopSetComment (short svRefNum, long lDirID, const uint8_t *pFilename, const char *pComment) noexcept
	Get a comment from the Desktop Manager.
int	Burger::DesktopCopyComment (short svRefNumDest, long lDirIDDest, const uint8_t *pFilenameDest, short svRefNumSource, long lDirIDSource, const uint8_t *pFilenameSource) noexcept
	Copy a comment from one file to another.
int	Burger::DesktopCopyComment (const FSSpec *pFSSpecDest, const FSSpec *pFSSpecSource) noexcept
	Copy a comment from one file to another.
int	Burger::DesktopCopyComment (const FSRef *pFSRefDest, const FSRef *pFSRefSource) noexcept
	Copy a comment from one file to another.
int	Burger::PreflightFileCopySpace (short svRefNumSource, long lDirIDSource, const uint8_t *pFilenameSource, const uint8_t *pVolumenameDest, short svRefNumDest, uint_t *pbSpaceAvailable) noexcept
	Determine if a destination volume has free file space.
int	Burger::OpenAware (short svRefNum, long lDirID, const uint8_t *pFilename, short sDenyModes, short *pRefNum) noexcept
	Open a file with OpenDeny modes.
int	Burger::OpenAware (const FSSpec *pFSSpec, short sDenyModes, short *pRefNum) noexcept
	Open a file with OpenDeny modes.
int	Burger::OpenRFAware (short svRefNum, long lDirID, const uint8_t *pFilename, short sDenyModes, short *pRefNum) noexcept
	Open a resource fork with OpenDeny modes.
int	Burger::OpenRFAware (const FSSpec *pFSSpec, short sDenyModes, short *pRefNum) noexcept
	Open a resource fork with OpenDeny modes.
int	Burger::FileCopy (short svRefNumSource, long lDirIDSource, const uint8_t *pFilenameSource, short svRefNumDest, long lDirIDDest, const uint8_t *pFilenameDest, const uint8_t *pCopyname, void *pBuffer, uintptr_t uBufferSize, uint_t bPreflight) noexcept
	Copy a file, with AppleShare awareness.
int	Burger::FileCopy (const FSSpec *pFSSpecSource, const FSSpec *pFSSpecDestFolder, const uint8_t *pCopyname, void *pBuffer, uintptr_t uBufferSize, uint_t bPreflight) noexcept
	Copy a file, with AppleShare awareness.
CodeLibrary *	Burger::GetInterfaceLib (void) noexcept
	Load InterfaceLib for manual linking.
CodeLibrary *	Burger::GetDriverLoaderLib (void) noexcept
	Load DriverLoaderLib for manual linking.
CodeLibrary *	Burger::GetNameRegistryLib (void) noexcept
	Load NameRegistryLib for manual linking.
void	Burger::PrintHexDigit (uint_t uInput) noexcept
	Print a hex character to standard out.
void	Burger::PrintHex (uint8_t uInput) noexcept
	Print an 8 bit value in hex to standard out.
void	Burger::PrintHex (uint16_t uInput) noexcept
	Print a 16 bit value in hex to standard out.
void	Burger::PrintHex (uint32_t uInput) noexcept
	Print a 32 bit value in hex to standard out.
void	Burger::PrintHex (uint64_t uInput) noexcept
	Print a 64 bit value in hex to standard out.
void	Burger::PrintHex (char iInput) noexcept
	Print a char in hex to standard out.
void	Burger::PrintHex (signed char iInput) noexcept
	Print a signed char in hex to standard out.
void	Burger::PrintHex (short iInput) noexcept
	Print a short in hex to standard out.
void	Burger::PrintHex (int iInput) noexcept
	Print an integer in hex to standard out.
void	Burger::PrintHex (long iInput) noexcept
	Print a long integer in hex to standard out.
void	Burger::PrintHex (long long iInput) noexcept
	Print a long long integer in hex to standard out.
void	Burger::PrintHex (wchar_t uInput) noexcept
	Print a wchar_t in hex to standard out.
void	Burger::PrintHex (unsigned int uInput) noexcept
	Print an unsigned integer in hex to standard out.
void	Burger::PrintHex (unsigned long uInput) noexcept
	Print an unsigned long integer in hex to standard out.
void	Burger::PrintHex (float fInput) noexcept
	Print a 32 bit floating pointer number in hex to standard out.
void	Burger::PrintHex (double dInput) noexcept
	Print a 64 bit floating point number in hex to standard out.
void	Burger::ClearConsole (void) noexcept
	Clear the text console.
uint_t	Burger::has_CPUID (void) noexcept
	Return TRUE if the instruction CPUID is present.
void	Burger::CPUID (CPUID_t *pOutput) noexcept
	Fill in a CPUID_t structure.
uint_t	Burger::has_AltiVec (void) noexcept
	Return TRUE if the AltiVec instruction set is present.
uint_t	Burger::has_PPC_fsqrt (void) noexcept
	Return TRUE if floating point sqrt is supported in hardware.
uint_t	Burger::has_68kFPU (void) noexcept
	Return TRUE if floating point is supported in hardware.
uint_t	Burger::atomic_compare_and_set (volatile uint32_t *pOutput, uint32_t uOld, uint32_t uNew) noexcept
	Atomically swaps a 32 bit value for one in memory.
uint32_t	Burger::atomic_set (volatile uint32_t *pOutput, uint32_t uInput) noexcept
	Atomically sets a 32 bit value to memory.
uint32_t	Burger::atomic_get (volatile uint32_t *pInput) noexcept
	Atomically gets a 32 bit value from memory.
uint32_t	Burger::atomic_add (volatile uint32_t *pOutput, uint32_t uInput) noexcept
	Atomically add a 32 bit value to a variable in memory.
uint_t	Burger::atomic_trylock (volatile uint32_t *pInput) noexcept
	Attempt to lock a spin lock.
void	Burger::atomic_lock (volatile uint32_t *pInput) noexcept
	Lock a spin lock.
void	Burger::atomic_unlock (volatile uint32_t *pInput) noexcept
	Unlock a spin lock.
uint_t	Burger::atomic_compare_and_set (volatile uint64_t *pOutput, uint64_t uOld, uint64_t uNew) noexcept
	Atomically swaps a 64 bit value for one in memory.
uint64_t	Burger::atomic_set (volatile uint64_t *pOutput, uint64_t uInput) noexcept
	Atomically sets a 64 bit value for one in memory.
uint64_t	Burger::atomic_get (volatile uint64_t *pInput) noexcept
	Atomically gets a 64 bit value from memory.
uint64_t	Burger::atomic_add (volatile uint64_t *pOutput, uint64_t uInput) noexcept
	Atomically add a 64 bit value to a variable in memory.
uint32_t	Burger::AsciiToInteger (const char *pInput, const char **pDest=nullptr) noexcept
	Convert an ASCII string into an integer.
int_t	Burger::AsciiToInteger (const char *pInput, int_t iDefault, int_t iMin=INT32_MIN, int_t iMax=INT32_MAX) noexcept
	Return a signed integer value.
uint_t	Burger::AsciiToInteger (uint32_t *pOutput, const char *pInput) noexcept
	Convert a 32 bit integer and signal if successful.
uint_t	Burger::AsciiToWord (const char *pInput, uint_t uDefault, uint_t uMin=0, uint_t uMax=0xFFFFFFFFU) noexcept
	Return an unsigned integer value.
uint64_t	Burger::AsciiToInteger64 (const char *pInput, const char **pDest=nullptr) noexcept
	Convert an ASCII string into a 64 bit integer.
int64_t	Burger::AsciiToInteger64 (const char *pInput, int64_t iDefault, int64_t iMin=INT64_MIN, int64_t iMax=INT64_MAX) noexcept
	Return a signed integer value.
uint_t	Burger::AsciiToInteger64 (uint64_t *pOutput, const char *pInput) noexcept
	Convert a 64 bit integer and signal if successful.
uint64_t	Burger::AsciiToWord64 (const char *pInput, uint64_t uDefault, uint64_t uMin=0, uint64_t uMax=0xFFFFFFFFFFFFFFFFULL) noexcept
	Return an unsigned integer value.
float	Burger::AsciiToFloat (const char *pInput, const char **pDest=nullptr) noexcept
	Convert an ASCII string into a floating point number.
double	Burger::AsciiToDouble (const char *pInput, const char **pDest=nullptr) noexcept
	Convert an ASCII string into a floating point number.
uint_t	Burger::AsciiToBoolean (const char *pInput, const char **pDest=nullptr) noexcept
	Convert an ASCII string into a boolean.
uint_t	Burger::AsciiToBoolean (const char *pInput, uint_t bDefault) noexcept
	Convert an ASCII string into a boolean.
uint_t	Burger::AsciiToBoolean (uint_t *pOutput, const char *pInput) noexcept
	Convert an ASCII string into a boolean and signal if successful.
float	Burger::AsciiToFloat (const char *pInput, float fDefault) noexcept
	Return a floating point value.
float	Burger::AsciiToFloat (const char *pInput, float fDefault, float fMin, float fMax) noexcept
	Return a floating point value.
uint_t	Burger::AsciiToFloat (float *pOutput, const char *pInput) noexcept
	Return a floating point value and signal if successful.
double	Burger::AsciiToDouble (const char *pInput, double dDefault) noexcept
	Return a 64 bit floating point value.
double	Burger::AsciiToDouble (const char *pInput, double dDefault, double dMin, double dMax) noexcept
	Return a 64 bit floating point value.
uint_t	Burger::AsciiToDouble (double *pOutput, const char *pInput) noexcept
	Return a 64 bit floating point value and signal if successful.
uint32_t	Burger::AsciiHexToInteger (const char *pInput, uintptr_t uLength) noexcept
	Convert hex ASCII string to an integer.
uint32_t	Burger::AsciiHexToInteger (const uint16_t *pInput, uintptr_t uLength) noexcept
	Convert hex UTF-16 string to an integer.
char *	Burger::NumberToAsciiHex (char *pOutput, uint8_t uInput) noexcept
	Convert an 8 bit value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, uint16_t uInput) noexcept
	Convert a 16 bit value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, uint32_t uInput) noexcept
	Convert a 32 bit value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, uint64_t uInput) noexcept
	Convert a 64 bit value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, float fInput) noexcept
	Convert a 32 bit floating point value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, double dInput) noexcept
	Convert a 64 bit floating point value into a hex string.
template<class T >
char *	Burger::NumberToAsciiHex (char *pOutput, T input) noexcept
	Convert a integral value into a hex string.
char *	Burger::NumberToAsciiHex (char *pOutput, uint32_t uInput, uint_t uDigits) noexcept
	Convert an unsigned 32 bit integer into hexadecimal ASCII.
char *	Burger::NumberToAsciiHex (char *pOutput, uint64_t uInput, uint_t uDigits) noexcept
	Convert an unsigned 64 bit integer into hexadecimal ASCII.
char *	Burger::NumberToAsciiHex (char *pOutput, float fInput, uint_t uDigits) noexcept
	Convert a 32 bit float into hexadecimal ASCII.
char *	Burger::NumberToAsciiHex (char *pOutput, double dInput, uint_t uDigits) noexcept
	Convert a 64 bit float into hexadecimal ASCII.
char *	Burger::NumberToAsciiHex (char *pOutput, uint8_t uInput, uint_t uDigits) noexcept
char *	Burger::NumberToAsciiHex (char *pOutput, uint16_t uInput, uint_t uDigits) noexcept
template<class T >
char *	Burger::NumberToAsciiHex (char *pOutput, T input, uint_t uDigits) noexcept
	Convert a integral value into a hex string.
char *	Burger::NumberToAscii (char *pOutput, uint32_t uInput, uint_t uDigits) noexcept
	Convert an unsigned 32 bit integer into ASCII.
char *	Burger::NumberToAscii (char *pOutput, int32_t iInput, uint_t uDigits) noexcept
	Convert a signed 32 bit integer into ASCII.
char *	Burger::NumberToAscii (char *pOutput, uint64_t uInput, uint_t uDigits) noexcept
	Convert an unsigned 64 bit integer into ASCII.
char *	Burger::NumberToAscii (char *pOutput, int64_t iInput, uint_t uDigits) noexcept
	Convert a signed 64 bit integer into ASCII.
char *	Burger::NumberToAscii (char *pOutput, float fInput, uint_t uDigits=0) noexcept
	Convert a 32 bit float into ASCII.
char *	Burger::NumberToAscii (char *pOutput, double dInput, uint_t uDigits=0) noexcept
	Convert a 64 bit float into ASCII.
template<class T >
char *	Burger::NumberToAscii (char *pOutput, T input) noexcept
template<class T >
char *	Burger::NumberToAscii (char *pOutput, T input, uint_t uDigits) noexcept
uint_t	Burger::NumberStringLength (uint32_t uInput) noexcept
	Calculate the length of a string that represents this integer.
uint_t	Burger::NumberStringLength (int32_t iInput) noexcept
	Calculate the length of a string that represents this integer.
uint_t	Burger::NumberStringLength (uint64_t uInput) noexcept
	Calculate the length of a string that represents this integer.
uint_t	Burger::NumberStringLength (int64_t iInput) noexcept
	Calculate the length of a string that represents this integer.
template<class T >
uint_t	Burger::NumberStringLength (T input) noexcept
	Calculate the length of a string that represents this integer.
uint_t	Burger::NumberHexStringLength (uint32_t uInput) noexcept
	Calculate the length of a string that represents this hex integer.
uint_t	Burger::NumberHexStringLength (uint64_t uInput) noexcept
	Calculate the length of a string that represents this hex integer.
template<class T >
uint_t	Burger::NumberHexStringLength (T input) noexcept
	Calculate the length of a string that represents this hex integer.
uint_t	Burger::NumberOctalStringLength (uint32_t uInput) noexcept
	Calculate the length of a string that represents this octal integer.
uint_t	Burger::NumberOctalStringLength (uint64_t uInput) noexcept
	Calculate the length of a string that represents this octal integer.
template<class T >
uint_t	Burger::NumberOctalStringLength (T input) noexcept
	Calculate the length of a string that represents this octal integer.
constexpr uint32_t	Burger::ToLower (uint32_t uInput) noexcept
	Convert a character to lower case.
constexpr uint32_t	Burger::ToUpper (uint32_t uInput) noexcept
	Convert a character to upper case.
uint_t	Burger::IsPointerInvalid (const void *pInput) noexcept
	Test if a pointer is invalid.
uint_t	Burger::IsPointerValid (const void *pInput) noexcept
	Test if a pointer is valid.
uint_t	Burger::IsStringEmpty (const char *pInput) noexcept
	Test if a UTF-8 string pointer points to a nullptr string.
uint_t	Burger::IsStringEmpty (const uint16_t *pInput) noexcept
	Test if a UTF-16 string pointer points to a nullptr string.
uint_t	Burger::IsDigit (char iInput) noexcept
	Test if a character is 0-9.
uint_t	Burger::IsHex (char iInput) noexcept
	Test if a character is 0-9, A-F or a-f.
uint_t	Burger::IsWhitespace (char iInput) noexcept
	Test if a character is TAB or SPACE.
uint_t	Burger::IsLowercase (char iInput) noexcept
	Test if a character is a-z.
uint_t	Burger::IsUppercase (char iInput) noexcept
	Test if a character is A-Z.
uint_t	Burger::IsSpace (int iInput) noexcept
	Test if a character is ASCII white space.
void	Burger::CStringToPString (uint8_t *pOutput, const char *pInput) noexcept
	Convert a "C" string into a Pascal string.
void	Burger::PStringToCString (char *pOutput, const uint8_t *pInput) noexcept
	Convert a Pascal string into a "C" string.
char *	Burger::ParseBeyondWhiteSpace (const char *pInput) noexcept
	Parse a "C" string until a non-white space character is found.
char *	Burger::ParseToDelimiter (const char *pInput) noexcept
	Return a pointer to whitespace, CR, LF or zero.
char *	Burger::ParseBeyondEOL (const char *pInput) noexcept
	Parse a "C" string until a zero or EOL.
char *	Burger::ParseBeyondEOL (const char *pInput, uintptr_t uLength) noexcept
	Parse a "C" string until a zero or EOL or out of data.
char *	Burger::ParseQuotedString (char *pOutput, uintptr_t uOutputSize, const char *pInput) noexcept
	Parse out a quoted string.
uintptr_t	Burger::CopyUpToEOL (char *pOutput, uintptr_t uOutputSize, const char *pInput, uintptr_t uInputSize) noexcept
	Read a stream of text chars until a nullptr, LF, CR or CR/LF is found.
void	Burger::StripLeadingSpaces (char *pInput) noexcept
	Remove spaces from the beginning of a string.
void	Burger::StripTrailingSpaces (char *pInput) noexcept
	Remove spaces from the end of a string.
void	Burger::StripLeadingWhiteSpace (char *pInput) noexcept
	Remove whitespace from the beginning of a string.
void	Burger::StripTrailingWhiteSpace (char *pInput) noexcept
	Remove whitespace from the end of a string.
void	Burger::StripLeadingAndTrailingSpaces (char *pInput) noexcept
	Remove spaces from the beginning and end of a string.
void	Burger::StripLeadingAndTrailingWhiteSpace (char *pInput) noexcept
	Remove whitespace from the beginning and end of a string.
void	Burger::StripAllFromList (char *pInput, const char *pList) noexcept
	Remove all characters that match those in a list.
void	Burger::StripAllButList (char *pInput, const char *pList) noexcept
	Remove all characters except those in a list.
void	Burger::StripTrailing (char *pInput, const char *pList) noexcept
	Remove characters from the end of a string.
void	Burger::StripLeading (char *pInput, const char *pList) noexcept
	Remove characters from the beginning of a string.
void	Burger::RemoveTrailingChar (char *pInput, uint_t uRemove) noexcept
	Remove a character from the end of a string if present.
void	Burger::ForceTrailingChar (char *pInput, uint_t uLast) noexcept
	Force a character to be at the end of a string if missing.
void	Burger::SlashesToColons (char *pInput) noexcept
	Convert all forward and back slashes to colons.
void	Burger::SlashesToColons (char *pOutput, const char *pInput) noexcept
	Convert all forward and back slashes to colons.
void	Burger::SlashesToWindowsSlashes (char *pInput) noexcept
	Convert all forward slashes ('/') to back slashes ('\').
void	Burger::SlashesToWindowsSlashes (char *pOutput, const char *pInput) noexcept
	Convert all forward slashes ('/') to back slashes ('\').
void	Burger::EndWithWindowsSlashes (char *pInput) noexcept
	Force the last character of a string to be '\'.
void	Burger::EndWithWindowsSlashes (char *pOutput, const char *pInput) noexcept
	Copy a string and force the last character of a string to be '\'.
void	Burger::SlashesToLinuxSlashes (char *pInput) noexcept
	Convert all back slashes ('\') to forward slashes ('/').
void	Burger::SlashesToLinuxSlashes (char *pOutput, const char *pInput) noexcept
	Convert all back slashes ('\') to forward slashes ('/').
void	Burger::EndWithLinuxSlashes (char *pInput) noexcept
	Force the last character of a string to be '/'.
void	Burger::EndWithLinuxSlashes (char *pOutput, const char *pInput) noexcept
	Copy a string and force the last character of a string to be '/'.
void	Burger::Replace (char *pInput, uint_t uFrom, uint_t uTo) noexcept
	Convert characters in a string from one to another.
void	Burger::Replace (char *pOutput, const char *pInput, uint_t uFrom, uint_t uTo) noexcept
	Convert characters in a string from one to another.
char *	Burger::GetFileExtension (const char *pInput) noexcept
	Get a pointer to the beginning of the file extension.
void	Burger::SetFileExtension (char *pInput, const char *pNewExtension) noexcept
	Replace the text after the last period for filename extensions.
uintptr_t	Burger::StringLength (const char *pInput) noexcept
	Perform an ANSI compatible strlen().
uintptr_t	Burger::StringLength (const uint16_t *pInput) noexcept
	Perform an ANSI compatible strlen() for UTF16 strings..
void	Burger::StringCopy (char *pOutput, const char *pInput) noexcept
	Copy a "C" string.
void	Burger::StringCopy (char *pOutput, uintptr_t uOutputSize, const char *pInput) noexcept
	Copy a "C" string with bounds checking.
void	Burger::StringCopy (char *pOutput, uintptr_t uOutputSize, const char *pInput, uintptr_t uInputSize) noexcept
	Copy a text buffer into a "C" string with bounds checking.
void	Burger::StringCopy (uint16_t *pOutput, const uint16_t *pInput) noexcept
	Copy a 16 bit "C" string.
void	Burger::StringCopy (uint16_t *pOutput, uintptr_t uOutputSize, const uint16_t *pInput) noexcept
	Copy a 16 bit "C" string with bounds checking.
void	Burger::StringCopy (uint16_t *pOutput, uintptr_t uOutputSize, const uint16_t *pInput, uintptr_t uInputSize) noexcept
	Copy a text buffer into a 16 bit "C" string with bounds checking.
char *	Burger::StringDuplicate (const char *pInput) noexcept
	Make a copy of a "C" string.
char *	Burger::StringDuplicate (const char *pInput, uintptr_t uPadding) noexcept
	Make a copy of a "C" string with some padding.
void	Burger::StringDelete (const char *pInput) noexcept
	Delete an allocated string.
void	Burger::StringConcatenate (char *pOutput, const char *pInput) noexcept
	Concatenate a "C" string with another "C" string.
void	Burger::StringConcatenate (char *pOutput, uintptr_t uOutputSize, const char *pInput) noexcept
	Concatenate a "C" string with another "C" string bounds checked.
void	Burger::StringConcatenate (char *pOutput, uintptr_t uOutputSize, const char *pInput, uintptr_t uInputSize) noexcept
	Concatenate a "C" string with a string buffer, bounds checked.
void	Burger::StringConcatenate (uint16_t *pOutput, const uint16_t *pInput) noexcept
	Concatenate a 16 bit "C" string with another 16 bit "C" string.
void	Burger::StringConcatenate (uint16_t *pOutput, uintptr_t uOutputSize, const uint16_t *pInput) noexcept
	Concatenate a 16 bit "C" string with another 16 bit "C" string bounds checked.
int	Burger::StringCompare (const char *pInput1, const char *pInput2) noexcept
	Compare two "C" strings for equality.
int	Burger::StringCompare (const char *pInput1, const char *pInput2, uintptr_t uMaxLength) noexcept
	Compare two "C" strings for equality, case sensitive, length delimited.
int	Burger::StringCompare (const uint16_t *pInput1, const uint16_t *pInput2) noexcept
	Compare two 16 bit "C" strings for equality.
int	Burger::StringCompare (const uint16_t *pInput1, const uint16_t *pInput2, uintptr_t uMaxLength) noexcept
	Compare two 16 bit "C" strings for equality, case sensitive, length delimited.
int	Burger::StringCaseCompare (const char *pInput1, const char *pInput2) noexcept
	Compare two "C" strings for equality, case insensitive.
int	Burger::StringCaseCompare (const char *pInput1, const char *pInput2, uintptr_t uMaxLength) noexcept
	Compare two "C" strings for equality, case insensitive, length delimited.
uint_t	Burger::Wildcardcmp (const char *pInput, const char *pWildcard) noexcept
	Perform a string comparison using the wild card system.
uint_t	Burger::HasWildcard (const char *pInput) noexcept
	Return TRUE if the string contains a wild card character.
void	Burger::StringUppercase (char *pInput) noexcept
	Convert a string to upper case.
void	Burger::StringUppercase (char *pOutput, const char *pInput) noexcept
	Convert a string to upper case into a new buffer.
void	Burger::StringLowercase (char *pInput) noexcept
	Convert a string to lower case.
void	Burger::StringLowercase (char *pOutput, const char *pInput) noexcept
	Convert a string to lower case into a new buffer.
char *	Burger::StringCharacter (const char *pInput, int iChar) noexcept
	Scan for the first occurrence of a specific character.
uint16_t *	Burger::StringCharacter (const uint16_t *pInput, uint_t uChar) noexcept
	Scan for the first occurrence of a specific character.
char *	Burger::StringCharacterReverse (const char *pInput, int iChar) noexcept
	Scan for the last occurrence of a specific character.
uint16_t *	Burger::StringCharacterReverse (const uint16_t *pInput, uint_t uChar) noexcept
	Scan for the last occurrence of a specific character.
uint_t	Burger::StringEndsWith (char *pInput, int iChar) noexcept
	Force the ending character of a string.
uint_t	Burger::StringEndsWith (uint16_t *pInput, uint_t uChar) noexcept
	Force the ending character of a string.
uintptr_t	Burger::StringSkipOver (const char *pInput, const char *pDelimiters) noexcept
	Locate the offset of the first non-delimiter in a string.
uintptr_t	Burger::StringSkipOver (const uint16_t *pInput, const uint16_t *pDelimiters) noexcept
	Locate the offset of the first non-delimiter in a string.
uintptr_t	Burger::StringStopAt (const char *pInput, const char *pDelimiters) noexcept
	Locate the offset of the first delimiter in a string.
uintptr_t	Burger::StringStopAt (const uint16_t *pInput, const uint16_t *pDelimiters) noexcept
	Locate the offset of a delimiter in a string.
char *	Burger::StringString (const char *pInput, const char *pTest) noexcept
	Locate a substring.
char *	Burger::StringString (const char *pInput, const char *pTest, uintptr_t uTestLength) noexcept
	Locate a substring.
uint16_t *	Burger::StringString (const uint16_t *pInput, const uint16_t *pTest) noexcept
	Locate a substring (UTF-16 version)
char *	Burger::StringCaseString (const char *pInput, const char *pTest) noexcept
	Locate a substring, case insensitive.
uint16_t *	Burger::StringCaseString (const uint16_t *pInput, const uint16_t *pTest) noexcept
	Locate a substring, case insensitive (UTF-16 version)
char *	Burger::StringToken (char *pInput, const char *pDelimiters, char **ppSave) noexcept
	Split a string into tokens.
uint16_t *	Burger::StringToken (uint16_t *pInput, const uint16_t *pDelimiters, uint16_t **ppSave) noexcept
	Split a string into tokens.
intptr_t	Burger::GetFormattedLength (const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	Reports the size of a formatted output in bytes without actually creating any formatted output.
intptr_t	Burger::SprintfUserAlloc (SafePrint::SprintfCallbackProc pCallback, void *pContext, uint_t bAddNull, const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	Print into a buffer that a callback allocates.
intptr_t	Burger::Sprintf (char *pOutput, const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	sprintf() clone
intptr_t	Burger::Snprintf (char *pOutput, uintptr_t uOutputSize, const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	snprintf() clone
intptr_t	Burger::Printf (const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	printf() clone
intptr_t	Burger::Fprintf (FILE *fp, const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	printf() clone
intptr_t	Burger::DebugSnprintf (char *pOutput, uintptr_t uOutputSize, const char *pFormat, uintptr_t uArgCount, const ArgumentType **ppArgs) noexcept
	Debug snprintf()
float	Burger::Unpack16ToFloat (int16_t iInput)
	Decompress a packed floating point number.
int16_t	Burger::PackFloatTo16 (float fInput)
	Convert a float in the range of 0.999999 to -0.999999 into a 16 bit packed integer.
float	Burger::Unpack16ToFloat (int16_t iInput, uint32_t uBaseExponent)
	Decompress a packed floating point number with a supplied base exponent.
int16_t	Burger::PackFloatTo16 (float fInput, uint32_t uBaseExponent)
	Convert a float in the range of a supplied exponent into a 16 bit packed integer.
uintptr_t	Burger::UnpackBytes (const uint8_t *pInput, uintptr_t uInputLength, uint8_t **ppOutput, uintptr_t *pOutputLength)
	Decompress data compressed with PackBytes from the Apple IIgs.
eUnixFlavor	Burger::UnixGetFlavor (void) noexcept
uint32_t	Burger::get_traceflags (void) noexcept
	Get the current debug tracing flag.
void	Burger::set_traceflags (uint32_t uTraceFlags) noexcept
	Set the current debug tracing flag.
uint32_t	Burger::get_hintflags (void) noexcept
	Get the current code hint flags.
void	Burger::set_hintflags (uint32_t uHintFlags) noexcept
	Set the current debug tracing flag.
const char *	Burger::GetEnvironmentString (const char *pKey) noexcept
	Retrieve an environment string.
eError	Burger::SetEnvironmentString (const char *pKey, const char *pInput) noexcept
	Set an environment string.
uint_t	Burger::IsElevated (void) noexcept
	Test if the application has elevated privileges.
eError	Burger::GetUserLoginName (String *pOutput) noexcept
	Retrieves the login name of the user associated with the current thread.
eError	Burger::GetUserRealName (String *pOutput) noexcept
	Get the real name of the current user.
eError	Burger::GetMachineName (String *pOutput) noexcept
	Get the name the user has called the computer.
eError	Burger::GetFullPathNameUTF8 (String *pOutput, const char *pInput) noexcept
eError	Burger::GetOSString (String *pOutput, int16_t iStringID) noexcept
eError	Burger::GetOSIndString (String *pOutput, int16_t iStringID, int16_t iIndex) noexcept
eError	Burger::GetMacModelIdentifier (String *pOutput) noexcept
void	Burger::StringCopy (String *pOutput, const __CFString *pInput) noexcept
	Convert an NSString to a Burger::String (MacOSX and Carbon Only)
eError	Burger::get_home_directory (String *pOutput) noexcept
	Return the path of the "home" folder.
eError	Burger::get_abspath (String *pOutput, const char *pInput) noexcept
	Return the absolute path of a pathname.
uintptr_t	Burger::SDBMHashFunctor (const void *pData, uintptr_t uDataSize) noexcept
	SDBM (Service Data Base Management) hash callback for HashMapShared.
uintptr_t	Burger::SDBMHashCaseFunctor (const void *pData, uintptr_t uDataSize) noexcept
	Case insensitive SDBM (Service Data Base Management) hash callback for HashMapShared.
uintptr_t	Burger::DJB2HashAddFunctor (const void *pData, uintptr_t uDataSize) noexcept
	DJB2 Additive hash callback for HashMapShared.
uintptr_t	Burger::DJB2HashAddCaseFunctor (const void *pData, uintptr_t uDataSize) noexcept
	Case insensitive DJB2 Additive hash callback for HashMapShared.
uintptr_t	Burger::DJB2HashXorFunctor (const void *pData, uintptr_t uDataSize) noexcept
	DJB2 Exclusive Or hash callback for HashMapShared.
uintptr_t	Burger::DJB2HashXorCaseFunctor (const void *pData, uintptr_t uDataSize) noexcept
	DJB2 Exclusive Or hash callback for HashMapShared.
uintptr_t	Burger::DJB2StringHashXorFunctor (const void *pData, uintptr_t uDataSize) noexcept
	DJB2 Exclusive Or hash callback for HashMapString.
uintptr_t	Burger::DJB2StringHashXorCaseFunctor (const void *pData, uintptr_t uDataSize) noexcept
	Case insensitive DJB2 Exclusive Or hash callback for HashMapStringCase.
uint_t	Burger::HashMapStringCaseTest (const void *pA, const void *pB) noexcept
	Case insensitive string test for HashMapStringCase.
void	Burger::MP3DCT64 (float *pOutput1, float *pOutput2, const float *pInput)
	MP3 Discrete cosine transform function.
void	Burger::MP3FHT (float *pInput, uintptr_t uCount)
	MP3 Fast Fourier (Hartley) transform.
void	Burger::MP3DCT36 (float *pSideSamples, float *pHybridOutput, float *pOutput, const float *pPrevious, const float *pBlockType)
	36 entry DCT for MP3
void	Burger::MP3DCT12 (float *pSideSamples, float *pHybridOutput, float *pOutput, const float *pPrevious, const float *pBlockType)
	12 entry DCT for MP3
void	Burger::sleep_ms (uint32_t uMilliseconds, uint_t bAlertable=0) noexcept
	Sleep the current thread.
uint_t	Burger::WriteBig (FILE *fp, uint16_t uInput)
	Write a big endian 16-bit integer to a file.
uint_t	Burger::WriteBig (FILE *fp, uint32_t uInput)
	Write a big endian 32-bit integer to a file.
uint_t	Burger::WriteBig (FILE *fp, uint64_t uInput)
	Write a big endian 64-bit integer to a file.
uint_t	Burger::WriteBig (FILE *fp, float fInput)
	Write a big endian 32-bit float to a file.
uint_t	Burger::WriteBig (FILE *fp, double dInput)
	Write a big endian 64-bit float to a file.
uint_t	Burger::WriteLittle (FILE *fp, uint16_t uInput)
	Write a little endian 16-bit integer to a file.
uint_t	Burger::WriteLittle (FILE *fp, uint32_t uInput)
	Write a little endian 32-bit integer to a file.
uint_t	Burger::WriteLittle (FILE *fp, uint64_t uInput)
	Write a little endian 64-bit integer to a file.
uint_t	Burger::WriteLittle (FILE *fp, float fInput)
	Write a little endian 32-bit float to a file.
uint_t	Burger::WriteLittle (FILE *fp, double dInput)
	Write a little endian 64-bit float to a file.
uint_t	Burger::WriteCString (FILE *fp, const char *pInput)
	Write a "C" string with the terminating zero to a file stream.
uint16_t	Burger::read_big_uint16 (FILE *fp)
	Read a big endian 16-bit integer from a file.
uint32_t	Burger::read_big_uint32 (FILE *fp)
	Read a big endian 32-bit integer from a file.
uint64_t	Burger::ReadBigWord64 (FILE *fp)
	Read a big endian 64-bit integer from a file.
float	Burger::ReadBigFloat (FILE *fp)
	Read a big endian 32-bit float from a file.
double	Burger::ReadBigDouble (FILE *fp)
	Read a big endian 64-bit float from a file.
uint16_t	Burger::read_little_uint16 (FILE *fp)
	Read a little endian 16-bit integer from a file.
uint32_t	Burger::read_little_uint32 (FILE *fp)
	Read a little endian 32-bit integer from a file.
uint64_t	Burger::ReadLittleWord64 (FILE *fp)
	Read a little endian 64-bit integer from a file.
float	Burger::ReadLittleFloat (FILE *fp)
	Read a little endian 32-bit float from a file.
double	Burger::ReadLittleDouble (FILE *fp)
	Read a little endian 64-bit float from a file.
uint_t	Burger::read_c_string (FILE *fp, char *pInput, uintptr_t uLength)
	Read a "C" string with the terminating zero to a file stream.
uintptr_t	Burger::GetSize (FILE *fp)
	Return the size of a file.
uint64_t	Burger::GetSize64 (FILE *fp)
	Return the size of a file with 64 bits.
eError	Burger::SaveFile (FILE *fp, const void *pData, uintptr_t uLength)
	Save memory to a file opened with fopen()
void *	Burger::LoadFile (FILE *fp, uintptr_t *uLength)
	Load a file opened with fopen() into memory.
void	Burger::SetBinaryMode (FILE *fp)
	Force an ANSI FILE * to binary mode.
eError	Burger::get (Point *pPoint, InputMemoryStream *pInput) noexcept
	Read in a MacOS Point from an InputMemoryStream.
eError	Burger::append (OutputMemoryStream *pOutput, const Point *pPoint) noexcept
	Write out a MacOS Point into an OutputMemoryStream.
eError	Burger::get (Rect *pRect, InputMemoryStream *pInput) noexcept
	Read in a MacOS Rect from an InputMemoryStream.
eError	Burger::append (OutputMemoryStream *pOutput, const Rect *pRect) noexcept
	Write out a MacOS Rect into an OutputMemoryStream.
eError	Burger::SimpleDecompressILBMRLE (void *pOutput, uintptr_t uOutputChunkLength, const void *pInput, uintptr_t uInputChunkLength)
	Decompress data using RLE compression.
eError	Burger::SimpleDecompressLZSS (void *pOutput, uintptr_t uOutputChunkLength, const void *pInput, uintptr_t uInputChunkLength)
eError	Burger::SimpleDecompressDeflate (void *pOutput, uintptr_t uOutputChunkLength, const void *pInput, uintptr_t uInputChunkLength)
	Decompress data using Deflate compression.
int	CodeEntry (Burger::GameApp *pGameApp)
	Main entry of the application code.
long	Burger::SetDeviceCursor (IDirect3DDevice9 *pDirect3DDevice9, HICON__ *hCursor)
	Convert a Windows HCURSOR for DirectX9.
uint_t	Burger::GetD3DFORMATColorChannelBits (uint_t uD3DFORMAT)
	Get the number of bits for a single color channel.
uint_t	Burger::GetD3DFORMATAlphaChannelBits (uint_t uD3DFORMAT)
	Get the number of bits for the alpha channel.
uint_t	Burger::GetD3DFORMATDepthBits (uint_t uD3DFORMAT)
	Get the number of bits for the depth channel.
uint_t	Burger::GetD3DFORMATStencilBits (uint_t uD3DFORMAT)
	Get the number of bits for the stencil channel.
uint_t	Burger::GetDXGI_FORMATColorChannelBits (uint_t uDXGI_FORMAT)
	Get the number of bits for a single color channel.
void	Burger::CopyPalette (RGBWord8_t *pOutput, const RGBWord8_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBWord8_t entries.
void	Burger::CopyPalette (RGBWord8_t *pOutput, const RGBAWord8_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBWord8_t entries from an array of RGBAWord8_t entries.
void	Burger::CopyPalette (RGBAWord8_t *pOutput, const RGBWord8_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBAWord8_t entries from an array of RGBWord8_t entries.
void	Burger::CopyPalette (RGBAWord8_t *pOutput, const RGBAWord8_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBAWord8_t entries from an array of RGBAWord8_t entries.
void	Burger::CopyPalette444 (RGBWord8_t *pOutput, const uint16_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBWord8_t entries from an array of 16 bit XRGB entries.
void	Burger::CopyPalette444 (RGBAWord8_t *pOutput, const uint16_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBAWord8_t entries from an array of 16 bit XRGB entries.
void	Burger::CopyPalette4444 (RGBWord8_t *pOutput, const uint16_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBWord8_t entries from an array of 16 bit ARGB entries.
void	Burger::CopyPalette4444 (RGBAWord8_t *pOutput, const uint16_t *pInput, uintptr_t uEntries=256)
	Copy an array of RGBAWord8_t entries from an array of 16 bit ARGB entries.
void	Burger::Convert (RGBFloat_t *pOutput, const HSL_t *pInput)
	Convert a HSL color to an RGB color.
void	Burger::Convert (HSL_t *pOutput, const RGBFloat_t *pInput)
	Convert an RGB color to HSL color.
void	Burger::CopyPalette256 (RGBWord8_t *pOutput, const RGBWord8_t *pInput, uint_t uStartIndex=0, uint_t uPaletteSize=256)
	Set a range of RGB color entries to a 256 entry palette.
void	Burger::CopyPalette256 (RGBWord8_t *pOutput, const RGBAWord8_t *pInput, uint_t uStartIndex=0, uint_t uPaletteSize=256)
	Set a range of RGB color entries to a 256 entry palette.
void	Burger::CopyPalette256 (RGBAWord8_t *pOutput, const RGBWord8_t *pInput, uint_t uStartIndex=0, uint_t uPaletteSize=256)
	Set a range of RGBA color entries to a 256 entry palette.
void	Burger::CopyPalette256 (RGBAWord8_t *pOutput, const RGBAWord8_t *pInput, uint_t uStartIndex=0, uint_t uPaletteSize=256)
	Set a range of RGBA color entries to a 256 entry palette.
void	Burger::ClearPalette (RGBWord8_t *pOutput, uintptr_t uPaletteSize=256)
	Clear an RGB palette.
void	Burger::ClearPalette (RGBAWord8_t *pOutput, uintptr_t uPaletteSize=256)
	Clear an RGBA palette.
void	Burger::FillPalette (RGBWord8_t *pOutput, const RGBWord8_t *pInput, uintptr_t uPaletteSize=256)
	Fill an RGB palette with a specific color.
void	Burger::FillPalette (RGBAWord8_t *pOutput, const RGBAWord8_t *pInput, uintptr_t uPaletteSize=256)
	Fill an RGBA palette with a specific color.
const char *	Burger::Vulkan::VkResultToString (int32_t iVkResult) noexcept
	Convert a VkResult enum into a valid string.
const char *	Burger::Vulkan::VkPresentModeKHRToString (int32_t iVkPresentModeKHR) noexcept
	Convert a VkPresentModeKHR enum into a valid string.
const char *	Burger::Vulkan::VkColorSpaceKHRToString (int32_t iVkColorSpaceKHR) noexcept
	Convert a VkColorSpaceKHR enum into a valid string.
const char *	Burger::Vulkan::VkDriverIdToString (int32_t iVkDriverId) noexcept
	Convert a VkDriverId enum into a valid string.
const char *	Burger::Vulkan::VkFormatToString (int32_t iVkFormat) noexcept
	Convert a VkFormat enum into a valid string.
const char *	Burger::Vulkan::VkImageTilingToString (int32_t iVkImageTiling) noexcept
	Convert a VkImageTiling enum into a valid string.
const char *	Burger::Vulkan::VkPointClippingBehaviorToString (int32_t iVkPointClippingBehavior) noexcept
	Convert a VkPointClippingBehavior enum into a valid string.
const char *	Burger::Vulkan::VkShaderFloatControlsIndependenceToString (int32_t iVkShaderFloatControlsIndependence) noexcept
	Convert a VkShaderFloatControlsIndependence enum into a valid string.
const char *	Burger::Vulkan::VkPhysicalDeviceTypeToString (int32_t iVkPhysicalDeviceType) noexcept
	Convert a VkPhysicalDeviceType enum into a valid string.
void	Burger::DecompressImage (RGBAWord8_t *pOutput, uintptr_t uOutputStride, uint_t uWidth, uint_t uHeight, const Dxt1Packet_t *pInput, uintptr_t uInputStride)
	Decompress an array of 4x4 block compressed with DXT1.
void	Burger::DecompressImage (RGBAWord8_t *pOutput, uintptr_t uOutputStride, uint_t uWidth, uint_t uHeight, const Dxt3Packet_t *pInput, uintptr_t uInputStride)
	Decompress an array of 4x4 block compressed with DXT3.
void	Burger::DecompressImage (RGBAWord8_t *pOutput, uintptr_t uOutputStride, uint_t uWidth, uint_t uHeight, const Dxt5Packet_t *pInput, uintptr_t uInputStride)
	Decompress an array of 4x4 block compressed with DXT5.
const void *	Burger::FindAIFFChunk (const void *pInput, uintptr_t uLength, uint32_t uChunkName)
	Scan an AIFF file for a specific chunk.
const void *	Burger::FindRIFFChunk (const void *pInput, uintptr_t uLength, uint32_t uChunkName)
	Scan a RIFF file for a specific chunk.
uint32_t	Burger::GetID3V2TagLength (const void *pInput)
	Parses the ID3V2 tag length.
uint_t	Burger::XInputStopRumbleOnAllControllers (void) noexcept
	Turn off rumbling on XInput managed controllers.
uint_t	Burger::XInputGetGamepadState (uint_t uWhich, XInputGamePad_t *pXInputGamePad, eXInputDeadZoneType uDeadZoneType=XINPUTDEADZONE_NONE) noexcept
	Read a controller using XInput.
uint_t	Burger::IsDeviceXInput (const GUID *pGuid) noexcept
	Test if a device GUID belongs to an XInput device.
void	Burger::CopySoundData (void *pOutput, const void *pInput, uintptr_t uLength, SoundManager::eDataType eType)
	Upload sound data.
void	Burger::ClearSoundData (void *pOutput, uintptr_t uLength, SoundManager::eDataType eType)
	Clear sound data.
void	Burger::CopyStereoInterleaved (void *pOutput, const uint8_t *pLeft, const uint8_t *pRight, uintptr_t uOutputSize)
	Merge a left and right audio channel into a single buffer.
void	Burger::CopyStereoInterleaved (void *pOutput, const uint16_t *pLeft, const uint16_t *pRight, uintptr_t uOutputSize)
	Merge a left and right audio channel into a single buffer.
void	Burger::ComputeReverb (uint8_t *pOutput, const uint8_t *pInput, uintptr_t uCount, uint_t uPercentage)
	Add in an 8 bit reverb.
void	Burger::ComputeReverb (int16_t *pOutput, const int16_t *pInput, uintptr_t uCount, uint_t uPercentage)
	Add in an 16 bit reverb.
uint_t	Burger::Upload (IDirectSoundBuffer *pBuffer, uintptr_t uOffset, const uint8_t *pInput, uintptr_t uInputLength)
	Upload sound data into a DirectSoundBuffer.
uint_t	Burger::Upload (IDirectSoundBuffer *pBuffer, uintptr_t uOffset, SoundManager::BufferDecoder *pBufferDecoder, uintptr_t uInputLength)
	Upload compressed sound data into a DirectSoundBuffer.
float	Burger::AudioDeviceGetMasterVolume (uint32_t uDeviceID)
uint_t	Burger::AudioDeviceSetMasterVolume (uint32_t uDeviceID, float fInput)
void	Burger::MACEExp1to6 (const uint8_t *pInput, uint8_t *pOutput, uintptr_t uPacketCount, MACEState_t *pInputState, MACEState_t *pOutputState, uint_t uNumChannels, uint_t uWhichChannel)
	Decompress audio compressed with MACE 6:1.
void	Burger::MACEExp1to3 (const uint8_t *pInput, uint8_t *pOutput, uintptr_t uPacketCount, MACEState_t *pInputState, MACEState_t *pOutputState, uint_t uNumChannels, uint_t uWhichChannel)
	Decompress audio compressed with MACE 3:1.
void	Burger::ImportS3MEffect (Sequencer::Command_t *pOutput, uint_t uS3MCommand, uint_t uS3MArgument)
	Convert an S3M effect command to a Burgerlib one.
uint_t	Burger::ImportS3M (Sequencer::SongPackage *pOutput, const uint8_t *pInput, uintptr_t uInputLength)
	Import an S3M file.
void	Burger::ImportITEffect (Sequencer::Command_t *pOutput, uint_t uITCommand, uint_t uITArgument)
	Convert an IT effect command to a Burgerlib one.
uint_t	Burger::ImportIT (Sequencer::SongPackage *pOutput, const uint8_t *pInput, uintptr_t uInputLength)
	Import an IT file.
const uint8_t *	Burger::ImportXMEffect (Sequencer::Command_t *pOutput, const uint8_t *pInput)
	Convert an XM effect command to a Burgerlib one.
uint_t	Burger::ImportXM (Sequencer::SongPackage *pOutput, const uint8_t *pInput, uintptr_t uInputLength)
	Import an XM file.
uint_t	Burger::IsSelfAssignedIPv4 (uint32_t uIP) noexcept
	Test if an IPv4 address is self assigned.
uint_t	Burger::IsIPv6Unspecified (const uint8_t *pIP) noexcept
	Test if an IPv6 address is unspecified.
uint_t	Burger::IsIPv6Loopback (const uint8_t *pIP) noexcept
	Test if an IPv6 address is a loop back address.
uint_t	Burger::IsIPv6Multicast (const uint8_t *pIP) noexcept
	Test if an IPv6 address is a multicast address.
uint_t	Burger::IsIPv6LinkLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 address is a link local address.
uint_t	Burger::IsIPv6SiteLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 address is a site local address.
uint_t	Burger::IsIPv6MappedIPv4 (const uint8_t *pIP) noexcept
	Test if an IPv6 address is an IPv4 address in a wrapper.
uint_t	Burger::IsIPv6CompatibleIPv4 (const uint8_t *pIP) noexcept
	Test if an IPv6 address is an IPv4 address in a wrapper.
uint_t	Burger::IsIPv6MulticastNodeLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 multicast address has node local scope.
uint_t	Burger::IsIPv6MulticastLinkLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 multicast address has link local scope.
uint_t	Burger::IsIPv6MulticastSiteLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 multicast address has site local scope.
uint_t	Burger::IsIPv6MulticastOrgLocal (const uint8_t *pIP) noexcept
	Test if an IPv6 multicast address has organization local scope.
uint_t	Burger::IsIPv6MulticastGlobal (const uint8_t *pIP) noexcept
	Test if an IPv6 multicast address has global scope.
eError	Burger::IPv4ToString (String *pOutput, uint32_t uIP, uint_t uPort=0xFFFFFFFFU) noexcept
	Convert an IPv4 address into a string.
eError	Burger::IPv6ToString (String *pOutput, const uint8_t *pIP, uint_t uPort=0xFFFFFFFFU) noexcept
	Convert an IPv6 address into a string.
eError	Burger::StringToIPv4 (const char *pInput, uint32_t *pIP, uint_t *pPort=0) noexcept
	Convert a string into an IPv4 address.
eError	Burger::StringToIPv6 (const char *pInput, uint8_t *pIP, uint_t *pPort=0) noexcept
	Convert a string into an IPv6 address.
eError	Burger::SocketSetBlocking (SocketType uSocket) noexcept
	Set a posix socket to blocking mode.
eError	Burger::SocketSetNonBlocking (SocketType uSocket) noexcept
	Set a posix socket to non-blocking mode.
eError	Burger::SocketTestForReading (SocketType uSocket) noexcept
	Test a posix socket if there's pending data.
eError	Burger::get_default_mac_address (MacAddress_t *pOutput) noexcept
	Get the MAC address.
void	Burger::MakeNetworkEnumQueryPacket (void *pPacket)
	Create a query packet for network server scanning.
uint_t	Burger::IsNetworkEnumQueryPacket (const void *pPacket, uintptr_t uPacketSize)
	Verify a query packet for network server scanning.
void	Burger::ChooseGridSize (uint_t *pXCellCount, uint_t *pYCellCount, const Vector4D_t *pBoundingRect, uintptr_t uItemCountEstimate, float fGridScale=0.707f)
	Determine the optimum size of a grid.
void	Burger::EdgeIntersectTest (float *pEdge1VSEdge2, float *pEdge2VSEdge1, const Vector2D_t *pEdge1V1, const Vector2D_t *pEdge1V2, const Vector2D_t *pEdge2V1, const Vector2D_t *pEdge2V2)
	Test two edges for intersection.
const char *	Burger::Flash::GetVersion (void)
	Return the version of the flash player.
float	Burger::Flash::TwipsToPixels (float fInput)
	Convert a value from Flash Twips to Pixels.
float	Burger::Flash::PixelsToTwips (float fInput)
	Convert a value from Pixels to Flash Twips.
void	Burger::Flash::TwipsToPixels (Vector2D_t *pInput)
	Convert a 2D point from Flash Twips to Pixels.
void	Burger::Flash::PixelsToTwips (Vector2D_t *pInput)
	Convert a 2D point from Pixels to Flash Twips.
uint32_t	Burger::Flash::TextureSizePower2 (uint32_t uInput)
	Convert a texture width/height to a power of 2.
uintptr_t	Burger::Flash::GetEncodedU32Length (uint32_t *pOutput, const uint8_t *pInput)
	Extract a 32 bit unsigned integer from a byte stream.
eActionScriptStandardMember	Burger::Flash::EnumerateStandardMember (const char *pName)
	Enumerate common class names.
eFileType	Burger::Flash::GetFileType (const char *pFilename)
	Enumerate support file extensions.
void	Burger::Flash::GetFullURL (Filename *pOutput, const Filename *pDirectory, const char *pInput)
	Create a full pathname.
uintptr_t	Burger::Flash::DisassembleActionScript (const uint8_t *pInput)
	Disassemble a line of ActionScript.

Variables
const uint32_float_t	Burger::g_fZero = {0x00000000U}
	Constant for 0.0f in the float format.
const uint32_float_t	Burger::g_fNegZero = {0x80000000U}
	Constant for -0.0f in the float format.
const uint32_float_t	Burger::g_fOne = {0x3F800000U}
	Constant for 1.0f in the float format.
const uint32_float_t	Burger::g_fNegOne = {0xBF800000U}
	Constant for -1.0f in the float format.
const uint32_float_t	Burger::g_fHalf = {0x3F000000U}
	Constant for 0.5f in the float format.
const uint32_float_t	Burger::g_fNegHalf = {0xBF000000U}
	Constant for -0.5f in the float format.
const uint32_float_t	Burger::g_fInf = {0x7F800000U}
	Constant for Infinity in the float format.
const uint32_float_t	Burger::g_fNegInf = {0xFF800000U}
	Constant for -Infinity in the float format.
const uint32_float_t	Burger::g_fNan = {0x7FBFFFFFU}
	Constant for signaling Not a Number (NaN) in the float format.
const uint32_float_t	Burger::g_fNegNan = {0xFFBFFFFFU}
	Constant for negative signaling Not a Number (NaN) in the float format.
const uint32_float_t	Burger::g_fQNan = {0x7FFFFFFFU}
	Constant for non signaling Not a Number (Nan) in the float format.
const uint32_float_t	Burger::g_fNegQNan = {0xFFFFFFFFU}
	Constant for negative non signaling Not a Number in the float format.
const uint32_float_t	Burger::g_fMin = {0x00800000U}
	Constant for smallest number (Non-zero) in the float format.
const uint32_float_t	Burger::g_fNegMin = {0x80800000U}
	Constant for negative smallest number (Non-zero) in the float format.
const uint32_float_t	Burger::g_fMax = {0x7F7FFFFFU}
	Constant for largest number in the float format.
const uint32_float_t	Burger::g_fNegMax = {0xFF7FFFFFU}
	Constant for negative largest number in the float format.
const uint32_float_t	Burger::g_fMinNoInteger = {0x4B000000}
	Constant for the smallest number that cannot have a fraction 8388608.0f.
const uint32_float_t	Burger::g_fNegMinNoInteger = {0xCB000000}
	Constant for the negative smallest number that cannot have a fraction -8388608.0f.
const uint32_float_t	Burger::g_fEpsilon = {0x34000000U}
	Constant for Epsilon in the float format.
const uint32_float_t	Burger::g_fNegEpsilon = {0xB4000000U}
	Constant for negative Epsilon in the float format.
const uint32_float_t	Burger::g_fQuarterPi = {0x3F490FDB}
	Constant for Pi*0.25f in the float format.
const uint32_float_t	Burger::g_fNegQuarterPi = {0xBF490FDB}
	Constant for -Pi*0.25f in the float format.
const uint32_float_t	Burger::g_fHalfPi = {0x3FC90FDB}
	Constant for Pi*0.5f in the float format.
const uint32_float_t	Burger::g_fNegHalfPi = {0xBFC90FDB}
	Constant for -Pi*0.5f in the float format.
const uint32_float_t	Burger::g_fPi = {0x40490FDB}
	Constant for Pi in the float format.
const uint32_float_t	Burger::g_fNegPi = {0xC0490FDB}
	Constant for -Pi in the float format.
const uint32_float_t	Burger::g_fPi2 = {0x40C90FDB}
	Constant for Pi*2 in the float format.
const uint32_float_t	Burger::g_fNegPi2 = {0xC0C90FDB}
	Constant for -Pi*2 in the float format.
const uint32_float_t	Burger::g_fPi4 = {0x41490FDB}
	Constant for Pi*4 in the float format.
const uint32_float_t	Burger::g_fNegPi4 = {0xC1490FDB}
	Constant for -Pi*4 in the float format.
const uint32_float_t	Burger::g_fCosPiDiv6 = {0x3F5DB3D7}
	Constant for get_cosine(Pi/6.0) in the float format.
const uint32_float_t	Burger::g_fNegCosPiDiv6 = {0xBF5DB3D7}
	Constant for -get_cosine(Pi/6.0) in the float format.
const uint32_float_t	Burger::g_fReciprocalHalfPi = {0x3F22F983}
	Constant for 1/(Pi*0.5f) in the float format.
const uint32_float_t	Burger::g_fNegReciprocalHalfPi = {0xBF22F983}
	Constant for -1/(Pi*0.5f) in the float format.
const uint32_float_t	Burger::g_fReciprocalPi = {0x3EA2F983}
	Constant for 1/Pi in the float format.
const uint32_float_t	Burger::g_fNegReciprocalPi = {0xBEA2F983}
	Constant for -1/Pi in the float format.
const uint32_float_t	Burger::g_fReciprocalPi2 = {0x3E22F983}
	Constant for 1/(Pi*2.0f) in the float format.
const uint32_float_t	Burger::g_fNegReciprocalPi2 = {0xBE22F983}
	Constant for -1/(Pi*2.0f) in the float format.
const uint32_float_t	Burger::g_fRadiansToDegrees = {0x42652EE1}
	Constant for 180/Pi in the float format.
const uint32_float_t	Burger::g_fNegRadiansToDegrees = {0xC2652EE1}
	Constant for -180/Pi in the float format.
const uint32_float_t	Burger::g_fDegreesToRadians = {0x3C8EFA35}
	Constant for Pi/180 in the float format.
const uint32_float_t	Burger::g_fNegDegreesToRadians = {0xBC8EFA35}
	Constant for -Pi/180 in the float format.
const uint32_float_t	Burger::g_fSqrt2 = {0x3FB504F3}
	Constant for sqrt(2) in the float format.
const uint32_float_t	Burger::g_fNegSqrt2 = {0xBFB504F3}
	Constant for -sqrt(2) in the float format.
const uint32_float_t	Burger::g_fLN2 = {0x3F317218}
	Constant for ln(2) in the float format.
const uint32_float_t	Burger::g_fNegLN2 = {0xBF317218}
	Constant for -ln(2) in the float format.
const uint32_float_t	Burger::g_fLN10 = {0x40135D8E}
	Constant for ln(10) in the float format.
const uint32_float_t	Burger::g_fNegLN10 = {0xC0135D8E}
	Constant for -ln(10) in the float format.
const uint32_float_t	Burger::g_f1Div255 = {0x3B808081}
	Constant for 1.0f/255.f in the float format.
const uint32_float_t	Burger::g_f1Div3 = {0x3EAAAAAB}
	Constant for 1.0f/3.f in the float format.
const uint32_float_t	Burger::g_f2Div3 = {0x3F2AAAAB}
	Constant for 2.0f/3.f in the float format.
const uint32_float_t	Burger::g_f65536 = {0x47800000}
	Constant for 65536.f in the float float.
const uint64_double_t	Burger::g_dZero = {0x0000000000000000ULL}
	Constant for 0.0 in the double format.
const uint64_double_t	Burger::g_dNegZero = {0x8000000000000000ULL}
	Constant for -0.0 in the double format.
const uint64_double_t	Burger::g_dOne = {0x3FF0000000000000ULL}
	Constant for 1.0 in the double format.
const uint64_double_t	Burger::g_dNegOne = {0xBFF0000000000000ULL}
	Constant for -1.0 in the double format.
const uint64_double_t	Burger::g_dHalf = {0x3FE0000000000000ULL}
	Constant for 0.5 in the double format.
const uint64_double_t	Burger::g_dNegHalf = {0xBFE0000000000000ULL}
	Constant for -0.5 in the double format.
const uint64_double_t	Burger::g_dInf = {0x7FF0000000000000ULL}
	Constant for Infinity in the double format.
const uint64_double_t	Burger::g_dNegInf = {0xFFF0000000000000ULL}
	Constant for -Infinity in the double format.
const uint64_double_t	Burger::g_dNan = {0x7FF7FFFFFFFFFFFFULL}
	Constant for signaling Not a Number (NaN) in the double format.
const uint64_double_t	Burger::g_dNegNan = {0xFFF7FFFFFFFFFFFFULL}
	Constant for negative signaling Not a Number (NaN) in the double format.
const uint64_double_t	Burger::g_dQNan = {0x7FFFFFFFFFFFFFFFULL}
	Constant for non signaling Not a Number (Nan) in the double format.
const uint64_double_t	Burger::g_dNegQNan = {0xFFFFFFFFFFFFFFFFULL}
	Constant for negative non signaling Not a Number (Nan) in the double format.
const uint64_double_t	Burger::g_dMin = {0x0010000000000000ULL}
	Constant for the smallest number (Non-zero) in the double format.
const uint64_double_t	Burger::g_dNegMin = {0x8010000000000000ULL}
	Constant for the negative smallest number (Non-zero) in the double format.
const uint64_double_t	Burger::g_dMax = {0x7FEFFFFFFFFFFFFFULL}
	Constant for the largest number in the double format.
const uint64_double_t	Burger::g_dNegMax = {0xFFEFFFFFFFFFFFFFULL}
	Constant for the negative largest number in the double format.
const uint64_double_t	Burger::g_dMinNoInteger = {0x4330000000000000ULL}
	Constant for the smallest number that cannot have a fraction 4503599627370496.0.
const uint64_double_t	Burger::g_dNegMinNoInteger
	Constant for the negative smallest number that cannot have a fraction -4503599627370496.0.
const uint64_double_t	Burger::g_dEpsilon = {0x3CB0000000000000ULL}
	Constant for Epsilon in the double format.
const uint64_double_t	Burger::g_dNegEpsilon = {0xBCB0000000000000ULL}
	Constant for negative Epsilon in the double format.
const uint64_double_t	Burger::g_dQuarterPi = {0x3FE921FB54442D18ULL}
	Constant for Pi*0.25 in the double format.
const uint64_double_t	Burger::g_dNegQuarterPi = {0xBFE921FB54442D18ULL}
	Constant for -Pi*0.25 in the double format.
const uint64_double_t	Burger::g_dHalfPi = {0x3FF921FB54442D18ULL}
	Constant for Pi*0.5 in the double format.
const uint64_double_t	Burger::g_dNegHalfPi = {0xBFF921FB54442D18ULL}
	Constant for -Pi*0.5 in the double format.
const uint64_double_t	Burger::g_dPi = {0x400921FB54442D18ULL}
	Constant for Pi in the double format.
const uint64_double_t	Burger::g_dNegPi = {0xC00921FB54442D18ULL}
	Constant for -Pi in the double format.
const uint64_double_t	Burger::g_dPi2 = {0x401921FB54442D18ULL}
	Constant for Pi*2 in the double format.
const uint64_double_t	Burger::g_dNegPi2 = {0xC01921FB54442D18ULL}
	Constant for -Pi*2 in the double format.
const uint64_double_t	Burger::g_dPi4 = {0x402921FB54442D18ULL}
	Constant for Pi*4 in the double format.
const uint64_double_t	Burger::g_dNegPi4 = {0xC02921FB54442D18ULL}
	Constant for -Pi*4 in the double format.
const uint64_double_t	Burger::g_dCosPiDiv6 = {0x3FEBB67AE8584CABULL}
	Constant for get_cosine(Pi/6.0) in the double format.
const uint64_double_t	Burger::g_dNegCosPiDiv6 = {0xBFEBB67AE8584CABULL}
	Constant for -get_cosine(Pi/6.0) in the double format.
const uint64_double_t	Burger::g_dReciprocalHalfPi
	Constant for 1/(Pi*0.5) in the double format.
const uint64_double_t	Burger::g_dNegReciprocalHalfPi
	Constant for -1/(Pi*0.5) in the double format.
const uint64_double_t	Burger::g_dReciprocalPi = {0x3FD45F306DC9C883ULL}
	Constant for 1/Pi in the double format.
const uint64_double_t	Burger::g_dNegReciprocalPi
	Constant for -1/Pi in the double format.
const uint64_double_t	Burger::g_dReciprocalPi2
	Constant for 1/(Pi*2) in the double format.
const uint64_double_t	Burger::g_dNegReciprocalPi2
	Constant for -1/(Pi*2) in the double format.
const uint64_double_t	Burger::g_dRadiansToDegrees
	Constant for 180/Pi in the double format.
const uint64_double_t	Burger::g_dNegRadiansToDegrees
	Constant for -180/Pi in the double format.
const uint64_double_t	Burger::g_dDegreesToRadians
	Constant for Pi/180 in the double format.
const uint64_double_t	Burger::g_dNegDegreesToRadians
	Constant for -Pi/180 in the double format.
const uint64_double_t	Burger::g_dSqrt2 = {0x3FF6A09E667F3BCDULL}
	Constant for sqrt(2) in the double format.
const uint64_double_t	Burger::g_dNegSqrt2 = {0xBFF6A09E667F3BCDULL}
	Constant for -sqrt(2) in the double format.
const uint64_double_t	Burger::g_dLN2 = {0x3FE62E42FEFA39EFULL}
	Constant for ln(2) in the double format.
const uint64_double_t	Burger::g_dNegLN2 = {0xBFE62E42FEFA39EFULL}
	Constant for -ln(2) in the double format.
const uint64_double_t	Burger::g_dLN10 = {0x40026BB1BBB55516ULL}
	Constant for ln(10) in the double format.
const uint64_double_t	Burger::g_dNegLN10 = {0xC0026BB1BBB55516ULL}
	Constant for -ln(10) in the double format.
const uint64_double_t	Burger::g_d1Div255 = {0x3F70101010101010ULL}
	Constant for 1.0/255.0 in the double format.
const uint64_double_t	Burger::g_d1Div3 = {0x3FD5555555555555ULL}
	Constant for 1.0/3.0 in the double format.
const uint64_double_t	Burger::g_d2Div3 = {0x447696695DBD1CC3ULL}
	Constant for 2.0/3.0 in the double format.
const uint64_double_t	Burger::g_d65536 = {0x40f0000000000000ULL}
	Constant for 65536.0 in the double format.
const uint16_t	Burger::g_u8087RoundToZero = 0x0F7F
	8087 control word to set rounding to zero
const uint16_t	Burger::g_u8087RoundToInfinity = 0x0B7F
	8087 control word to set rounding to +infinity
const uint16_t	Burger::g_u8087RoundToNegativeInfinity = 0x077F
	8087 control word to set rounding to -infinity
const GUID	Burger::g_GUID_zero
	Empty GUID.
const uint32_float_t	Burger::g_X86HalfAndNegHalf [2]
	0.5f,-0.5f for roundup / rounddown
constexpr const Frac32	Burger::kMinFrac32 = (-0x7FFFFFFF) - 1
	Minimum value for Frac32.
constexpr const Frac32	Burger::kMaxFrac32 = 0x7FFFFFFF
	Maximum value for Frac32.
constexpr const Fixed32	Burger::kMinFixed32 = (-0x7FFFFFFF) - 1
	Minimum value for Fixed32.
constexpr const Fixed32	Burger::kMaxFixed32 = 0x7FFFFFFF
	Maximum value for Fixed32.
constexpr const Fixed32	Burger::kPiFixed32 = 0x003243F
	Pi in Fixed32 format (3.141... * 65536 = 205887.416)
const char	Burger::g_EmptyString [1] = {0}
	"" This string is hard coded to be an empty string. It saves space by having a singular occurrence.
const char	Burger::g_CRLFString [3] = {'\r', '\n', 0}
	"\r\n"
const char	Burger::g_CRString [2] = {'\r', 0}
	"\r"
const char	Burger::g_LFString [2] = {'\n', 0}
	"\n"
const char	Burger::g_TokenDelimiters [5] = {' ', '\t', '\r', '\n', 0}
	" \t\r\n"
const char	Burger::g_TrueString [5] = {'t', 'r', 'u', 'e', 0}
	"true"
const char	Burger::g_FalseString [6] = {'f', 'a', 'l', 's', 'e', 0}
	"false"
const char	Burger::g_YesString [4] = {'y', 'e', 's', 0}
	"yes"
const char	Burger::g_NoString [3] = {'n', 'o', 0}
	"no"
const char	Burger::g_NullString [7] = {'(', 'n', 'u', 'l', 'l', ')', 0}
	String to print when a NULL pointer is found.
const char *	Burger::g_WeekDays [7]
	Days of the week.
const char *	Burger::g_Months [12]
	Months of the year.
const char *	Burger::g_pBoolStrings [2]
	Strings to print for a boolean.
const uint16_t	Burger::g_EmptyString16 [1] = {0}
	"" in UTF16
const uint16_t	Burger::g_CRLFString16 [3] = {'\r', '\n', 0}
	"\r\n" in UTF16
const uint16_t	Burger::g_CRString16 [2] = {'\r', 0}
	"\r" in UTF16
const uint16_t	Burger::g_LFString16 [2] = {'\n', 0}
	"\n" in UTF16
const uint16_t	Burger::g_TokenDelimiters16 [5] = {' ', '\t', '\r', '\n', 0}
	" \t\r\n" in UTF16
const uint16_t	Burger::g_TrueString16 [5] = {'t', 'r', 'u', 'e', 0}
	"true" in UTF16
const uint16_t	Burger::g_FalseString16 [6] = {'f', 'a', 'l', 's', 'e', 0}
	"false" in UTF16
const uint16_t	Burger::g_YesString16 [4] = {'y', 'e', 's', 0}
	"yes" in UTF16
const uint16_t	Burger::g_NoString16 [3] = {'n', 'o', 0}
	"no" in UTF16
const uint8_t	Burger::g_AsciiTestTable [256]
	Table to quickly determine the type of low ASCII character.
const char	Burger::g_NibbleToAsciiUppercase [16]
	Table to convert nibbles (0-15) into upper case ASCII characters.
const char	Burger::g_NibbleToAsciiLowercase [16]
	Table to convert nibbles (0-15) into lower case ASCII characters.
const uint8_t	Burger::g_AsciiToWord8Table [256]
	Table to convert ASCII characters into nibbles (0-15).
const uint8_t	Burger::g_reverse_bits [256]
	Table to reverse the bit order of a byte.
const uint32_t	Burger::g_TensTable32 [10]
	Table used for testing powers of ten for 32 bit integer to ASCII conversion.
const uint64_t	Burger::g_TensTable64 [20]
	Table used for testing powers of ten for 64 bit integer to ASCII conversion.
const char *	Burger::g_VolumePrefixes [kUnixStadia+1]
	Folder for mounted volumes.
const Vector2D_t	Burger::g_Vector2DZero = {0.0f, 0.0f}
	Constant of 0.0f,0.0f.
const Vector2D_t	Burger::g_Vector2DOne = {1.0f, 1.0f}
	Constant of 1.0f,1.0f.
const Vector2D_t	Burger::g_Vector2DOneX = {1.0f, 0.0f}
	Constant of 1.0f,0.0f.
const Vector2D_t	Burger::g_Vector2DOneY = {0.0f, 1.0f}
	Constant of 0.0f,1.0f.
const Word32ToVector2D_t	Burger::g_Vector2DMax
	Constant of Burger::g_fMax,Burger::g_fMax.
const Word32ToVector2D_t	Burger::g_Vector2DInfinity
	Constant of Burger::g_fInf,Burger::g_fInf.
const Vector3D_t	Burger::g_Vector3DZero = {0.0f, 0.0f, 0.0f}
	Constant of 0.0f,0.0f,0.0f.
const Vector3D_t	Burger::g_Vector3DOne = {1.0f, 1.0f, 1.0f}
	Constant of 1.0f,1.0f,1.0f.
const Vector3D_t	Burger::g_Vector3DOneX = {1.0f, 0.0f, 0.0f}
	Constant of 1.0f,0.0f,0.0f.
const Vector3D_t	Burger::g_Vector3DOneY = {0.0f, 1.0f, 0.0f}
	Constant of 0.0f,1.0f,0.0f.
const Vector3D_t	Burger::g_Vector3DOneZ = {0.0f, 0.0f, 1.0f}
	Constant of 0.0f,0.0f,1.0f.
const Word32ToVector3D_t	Burger::g_Vector3DMax
	Constant of Burger::g_fMax,Burger::g_fMax,Burger::g_fMax.
const Word32ToVector3D_t	Burger::g_Vector3DInfinity
	Constant of Burger::g_fInf,Burger::g_fInf,Burger::g_fInf.
const Vector4D_t	Burger::g_Vector4DZero = {0.0f,0.0f,0.0f,0.0f}
	Constant of 0.0f,0.0f,0.0f,0.0f.
const Vector4D_t	Burger::g_Vector4DOne = {1.0f,1.0f,1.0f,1.0f}
	Constant of 1.0f,1.0f,1.0f,1.0f.
const Vector4D_t	Burger::g_Vector4DOneX = {1.0f,0.0f,0.0f,0.0f}
	Constant of 1.0f,0.0f,0.0f,0.0f.
const Vector4D_t	Burger::g_Vector4DOneY = {0.0f,1.0f,0.0f,0.0f}
	Constant of 0.0f,1.0f,0.0f,0.0f.
const Vector4D_t	Burger::g_Vector4DOneZ = {0.0f,0.0f,1.0f,0.0f}
	Constant of 0.0f,0.0f,1.0f,0.0f.
const Vector4D_t	Burger::g_Vector4DOneW = {0.0f,0.0f,0.0f,1.0f}
	Constant of 0.0f,0.0f,0.0f,1.0f.
const FixedVector3D_t	Burger::s_FixedVector3DZero = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 0.0f,0.0f,0.0f in fixed point.
const FixedVector3D_t	Burger::s_FixedVector3DOne = {BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(1.0f)}
	Constant of 1.0f,1.0f,1.0f in fixed point.
const FixedVector3D_t	Burger::s_FixedVector3DOneX = {BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 1.0f,0.0f,0.0f in fixed point.
const FixedVector3D_t	Burger::s_FixedVector3DOneY = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 0.0f,1.0f,0.0f in fixed point.
const FixedVector3D_t	Burger::s_FixedVector3DOneZ = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(1.0f)}
	Constant of 0.0f,0.0f,1.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DZero = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 0.0f,0.0f,0.0f,0.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DOne = {BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(1.0f)}
	Constant of 1.0f,1.0f,1.0f,1.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DOneX = {BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 1.0f,0.0f,0.0f,0.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DOneY = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 0.0f,1.0f,0.0f,0.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DOneZ = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(1.0f),BURGER_FLOAT_TO_FIXED(0.0f)}
	Constant of 0.0f,0.0f,1.0f,0.0f in fixed point.
const FixedVector4D_t	Burger::s_FixedVector4DOneW = {BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(0.0f),BURGER_FLOAT_TO_FIXED(1.0f)}
	Constant of 0.0f,0.0f,0.0f,1.0f in fixed point.
const Matrix3D_t	Burger::g_Matrix3DIdentity
	Constant 3x3 identity matrix.
const Matrix4D_t	Burger::s_Matrix4DIdentity
	Constant 4x4 identity matrix.
const FixedMatrix3D_t	Burger::s_FixedMatrix3DIdentity
	Constant 3x3 fixed point identity matrix.
const FixedMatrix4D_t	Burger::s_FixedMatrix4DIdentity
	Constant 4x4 fixed point identity matrix.
const uint32_float_t *	Burger::g_pMP3CosinePoints [5] = { g_MP3Cosine64, g_MP3Cosine32, g_MP3Cosine16, g_MP3Cosine8, g_MP3Cosine4 }
	Array of cosine points.
const uint32_float_t	Burger::g_MP3FHTCosines [4][2]
	4 pairs of FHT cosine/sine values for MP3 encoding
const uint32_float_t	Burger::g_MP3DCT36Constants [18]
	MP3 Layer 3 table for MP3DCT36.
const uint32_float_t	Burger::g_MP3DCT12Constants [3]
	MP3 Layer 3 table for 0.5 / cos((Burger::g_dPi * (i*2+1)) / 12.0)
const uint8_t	Burger::g_pscclr4dx9 []
const uint8_t	Burger::g_pstex2clr4dx9 []
const uint8_t	Burger::g_pstexturedx9 []
const uint8_t	Burger::g_pstexturecolordx9 []
const uint8_t	Burger::g_vs20pos22ddx9 []
const uint8_t	Burger::g_vs20pos2tex2clr42ddx9 []
const uint8_t	Burger::g_vs20sprite2ddx9 []
const uint8_t	Burger::g_vsstaticpositiondx9 []
const char	Burger::g_glDiffuseTexture [15]
	(OpenGL only) "DiffuseTexture"
const char	Burger::g_glPosition [9]
	(OpenGL only) "Position"
const char	Burger::g_glTexcoord [9]
	(OpenGL only) "Texcoord"
const char	Burger::g_glColor [6]
	(OpenGL only) "Color"
const char	Burger::g_glViewProjectionMatrix [21]
	(OpenGL only) "ViewProjectionMatrix"
const char	Burger::g_glXYWidthHeight [14]
	(OpenGL only) "XYWidthHeight"
const char	Burger::g_pscclr4gl []
const char	Burger::g_pstex2clr4gl []
const char	Burger::g_pstexturegl []
const char	Burger::g_pstexturecolorgl []
const char	Burger::g_vs20pos22dgl []
const char	Burger::g_vs20pos2tex2clr42dgl []
const char	Burger::g_vs20sprite2dgl []
const char	Burger::g_vsstaticpositiongl []
const uint32_t	Burger::g_pscclr4360 []
const uint32_t	Burger::g_pstex2clr4360 []
const uint32_t	Burger::g_pstexture360 []
const uint32_t	Burger::g_pstexturecolor360 []
const uint32_t	Burger::g_vs20pos22d360 []
const uint32_t	Burger::g_vs20pos2tex2clr42d360 []
const uint32_t	Burger::g_vs20sprite2d360 []
const uint32_t	Burger::g_vsstaticposition360 []
const uint8_t	Burger::g_pstexturevitaimage []
const uint8_t	Burger::g_pstexturecolorvitaimage []
const uint8_t	Burger::g_vs20sprite2dvitaimage []
const uint8_t	Burger::g_vsstaticpositionvitaimage []
const uint_t	Burger::g_Effect2DMemberDescription []
	Vertex description for Effect2D 2 entries for position 2 entries for UV.
const VertexBuffer::VertexAoS_t	Burger::g_Effect2DDefaultVertexBufferDescription
	Describe the location for Effect2D.
const uint_t	Burger::g_Shader2DColorVertexMemberDescription []
	Vertex description for Shader2DColorVertex 2 entries for position 2 entries for UV 4 entries for color.
const VertexBuffer::VertexAoS_t	Burger::g_Shader2DColorVertexDefaultVertexBufferDescription
	Describe the location for Shader2DColorVertex.
const uint_t	Burger::g_Shader2DCColorMemberDescription []
	Vertex description for Shader2DCColor 2 entries for position.
const VertexBuffer::VertexAoS_t	Burger::g_Shader2DCColorDefaultVertexBufferDescription
	Describe the location for Shader2DCColor.

Detailed Description

The master all inclusive header.

---

This header contains everything that is in Burgerlib in a single header.

By merging all the headers into a single file, it greatly improves the speed of compilation for most modern compilers. A secondary header with platform specific function is included with this header so only the functions specific to a platform are included for that platform, again for speed.

Note

This header is generated with the makeheader tool. Editing this header directly will likely have the modifications overwritten after the next build.

Copyright (c) 1995-2023 by Rebecca Ann Heineman becky.nosp@m.@bur.nosp@m.gerbe.nosp@m.cky..nosp@m.com

It is released under an MIT Open Source license. Please see LICENSE for license details. Yes, you can use it in a commercial title without paying anything, just give me a credit.

Please? It's not like I'm asking you for money!

Documentation can be found at https://burgerlib.readthedocs.io/en/latest/index.htm

Comments, suggestions, bug fixes, email me at becky.nosp@m.@bur.nosp@m.gerbe.nosp@m.cky..nosp@m.com

Macro Definition Documentation

__GNUC_PREREQ

#define __GNUC_PREREQ	(		maj,
			min )

Value:

0

GNUC version test macro.

---

On GNUC compilers, this compiles to 0. This was taken from features.h

[features.h documentation for this macro] (https://sites.uclouvain.be/SystInfo/usr/include/features.h.html)

See also

BURGER_GNUC

__has_attribute

#define __has_attribute

(

x

)

Value:

0

Clang feature macro for __has_attribute.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_attribute] (https://clang.llvm.org/docs/LanguageExtensions.html#has-attribute)

See also

BURGER_CLANG

__has_builtin

#define __has_builtin

(

x

)

Value:

0

Clang feature macro for __has_builtin.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_builtin] (https://clang.llvm.org/docs/LanguageExtensions.html#has-builtin)

See also

BURGER_CLANG

__has_cpp_attribute

#define __has_cpp_attribute

(

x

)

Value:

0

Clang feature macro for __has_cpp_attribute.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_cpp_attribute] (https://clang.llvm.org/docs/LanguageExtensions.html#has-cpp-attribute)

See also

BURGER_CLANG

__has_declspec_attribute

#define __has_declspec_attribute

(

x

)

Value:

0

Clang feature macro for __has_declspec_attribute.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_declspec_attribute] (https://clang.llvm.org/docs/LanguageExtensions.html#has-declspec-attribute)

See also

BURGER_CLANG

__has_extension

#define __has_extension   __has_feature

Clang feature macro for __has_extension.

---

On non-clang compilers, this remaps to __has_feature, which could also be 0.

[Clang documentation on __has_extension] (https://clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension)

See also

BURGER_CLANG

__has_feature

#define __has_feature

(

x

)

Value:

0

Clang feature macro for __has_feature.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_feature] (https://clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension)

See also

BURGER_CLANG

__has_include

#define __has_include

(

x

)

Value:

0

Clang feature macro for __has_include.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_include] (https://clang.llvm.org/docs/LanguageExtensions.html#has-include)

See also

BURGER_CLANG

__has_include_next

#define __has_include_next

(

x

)

Value:

0

Clang feature macro for __has_include_next.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_include_next] (https://clang.llvm.org/docs/LanguageExtensions.html#has-include-next)

See also

BURGER_CLANG

__has_warning

#define __has_warning

(

x

)

Value:

0

Clang feature macro for __has_warning.

---

On non-clang compilers, this compiles to 0.

[Clang documentation on __has_warning] (https://clang.llvm.org/docs/LanguageExtensions.html#has-warning)

See also

BURGER_CLANG

BURGER_64BITCPU

#define BURGER_64BITCPU

Define to determine if the CPU has 64 bit integer registers.

---

On BURGER_XBOXONE, BURGER_PS4, BURGER_AMD64, BURGER_PS3 and BURGER_XBOX360 platforms, the CPU has integer registers that are 64-bits wide. Using this define, code can be written that takes advantage of this. Mostly useful with Fixed32 and other high precision fixed point calculations.

See also

BURGER_XBOXONE, BURGER_PS4, BURGER_PS3, BURGER_XBOX360, or BURGER_AMD64

BURGER_68881

#define BURGER_68881

Define to determine if code is being built for Motorola 680x0 processor with a 68881 floating point unit.

---

If this define exists, then you are creating code that runs on the Motorola 680x0 line of processors with floating point hardware.

See also

BURGER_68K

BURGER_68K_A0

#define BURGER_68K_A0   :__A0

Macro for register passing for 68K compilers.

---

Use this macro for a pointer passed in the 68000 register A0.

Metrowerks and the Apple SC compilers allow register passing if a register is specifically appended to a function parameter or a function declaration. On all other platforms, these macros will convert to nothing.

// Have the function accept the parameter in D1 on 68K
extern void foobar(int input BURGER_68K_D1);
 
uint32_t bar(uint32_t *pInput BURGER_68K_A1) BURGER_68K_D1
{
    // Input is passed in A1, and loaded into D1 for return
    // This compiles to a single instruction and a RET
    return *pInput;
}

See also

BURGER_68K_A1, BURGER_68K_D0, or BURGER_68K_D1

BURGER_68K_A1

#define BURGER_68K_A1   :__A1

Macro for register passing for 68K compilers.

---

Use this macro for a pointer passed in the 68000 register A1.

Metrowerks and the Apple SC compilers allow register passing if a register is specifically appended to a function parameter or a function declaration. On all other platforms, these macros will convert to nothing.

// Have the function accept the parameter in D1 on 68K
extern void foobar(int input BURGER_68K_D1);
 
uint32_t bar(uint32_t *pInput BURGER_68K_A1) BURGER_68K_D1
{
    // Input is passed in A1, and loaded into D1 for return
    // This compiles to a single instruction and a RET
    return *pInput;
}

See also

BURGER_68K_A0, BURGER_68K_D0, or BURGER_68K_D1

BURGER_68K_D0

#define BURGER_68K_D0   :__D0

Macro for register passing for 68K compilers.

---

Use this macro for 8, 16, or 32 bit integer passed in the 68000 register D0.

Metrowerks and the Apple SC compilers allow register passing if a register is specifically appended to a function parameter or a function declaration. On all other platforms, these macros will convert to nothing.

// Have the function accept the parameter in D1 on 68K
extern void foobar(int input BURGER_68K_D1);
 
uint32_t bar(uint32_t *pInput BURGER_68K_A1) BURGER_68K_D1
{
    // Input is passed in A1, and loaded into D1 for return
    // This compiles to a single instruction and a RET
    return *pInput;
}

See also

BURGER_68K_A0, BURGER_68K_A1, or BURGER_68K_D1

BURGER_68K_D1

#define BURGER_68K_D1   :__D1

Macro for register passing for 68K compilers.

---

Use this macro for 8, 16, or 32 bit integer passed in the 68000 register D1.

Metrowerks and the Apple SC compilers allow register passing if a register is specifically appended to a function parameter or a function declaration. On all other platforms, these macros will convert to nothing.

// Have the function accept the parameter in D1 on 68K
extern void foobar(int input BURGER_68K_D1);
 
uint32_t bar(uint32_t *pInput BURGER_68K_A1) BURGER_68K_D1
{
    // Input is passed in A1, and loaded into D1 for return
    // This compiles to a single instruction and a RET
    return *pInput;
}

See also

BURGER_68K_A0, BURGER_68K_A1, or BURGER_68K_D0

BURGER_ADDRESS_SANITIZER

#define BURGER_ADDRESS_SANITIZER

Detect if address sanitization is active.

---

If the code is being built with Address Sanitization, this macro will exist.

See also

BURGER_DISABLE_ASAN or BURGER_CLANG

BURGER_ALIGN

#define BURGER_ALIGN	(		__type,
			__name,
			__a )

Value:

alignas(__a) __type __name

Macro to force data alignment.

---

Some data needs to be aligned differently than native alignment. Use this macro to have a compiler agnostic way to ensure data is aligned in a method that is desired by the programmer.

Note

The size must be a power of two. Acceptable sizes are 1, 2, 4, 8, 16 and 32. Larger are acceptable, as long as they are powers of two.

BURGER_ALIGN(extern int, foo, 8);
BURGER_ALIGN(CoolClass, MyClass, 1);
BURGER_ALIGN(int, DataArray[4], 8) = {1,2,3,4};

See also

BURGER_NO_ALIGN, BURGER_PREALIGN and BURGER_POSTALIGN

BURGER_ALLOW_WEAK_POINTERS

#define BURGER_ALLOW_WEAK_POINTERS

(

)

Value:

public: \
    BURGER_INLINE ProxyReferenceCounter* GetProxyReferenceCounter(void) \
        const BURGER_NOEXCEPT \
    { \
        return m_WeakPointerAnchor.GetProxyReferenceCounter(); \
    } \
\
private: \
    WeakPointerAnchor m_WeakPointerAnchor

Creates support for Burger::WeakPointer.

---

Burger::WeakPointer requires the function GetProxyReferenceCounter() that returns a valid Burger::ProxyReferenceCounter for tracking. This macro will insert the function and a Burger::WeakPointerAnchor member variable to support this functionality.

class SharedObject {
    // Allow WeakPointer to work
    BURGER_ALLOW_WEAK_POINTERS();
public:
    void DoStuff(void);
};
 
void foo()
{
    Burger::WeakPointer<SharedObject> pShared;
    {
        SharedObject shared;
        pShared = &shared;
    }
    if (pShared.GetPtr()==nullptr) {
        printf("shared is out of scope!!");
    }
}

Note

This macro will set the class setting to "private"

See also

Burger::WeakPointerAnchor, Burger::ProxyReferenceCounter or Burger::WeakPointer

BURGER_ALTIVEC

#define BURGER_ALTIVEC

Define to determine if code is being built for PowerPC Altivec instruction set extensions.

---

If this define exists, then you are creating code that runs on the PowerPC line of processors with Altivec instructions.

See also

BURGER_PPC, BURGER_POWERPC, or BURGER_POWERPC64

BURGER_ANSIAPI

#define BURGER_ANSIAPI

Default parameter passing type for ANSI library functions.

---

On Intel platforms, there are several methods of passing parameters. ANSI uses the __cdecl keyword, so any ANSI function like qsort() or atexit() that needs a callback function should have this keyword before the user supplied callback. It will ensure that the linkage will be correct. This will evaluate to nothing on non-Intel platforms.

static int BURGER_ANSIAPI Compare(const void *a,const void *b)
{
    return strcmp((char *)a,(char *)b);
}
 
void SortData(void)
{
    qsort(array,arraycount,sizeof(array[0]),Compare);
}

See also

BURGER_API

BURGER_API

#define BURGER_API

Default parameter passing type for Burgerlib functions.

---

On Intel platforms, there are several methods of passing parameters. Burgerlib uses the __fastcall method and this define will evaluate to __fastcall on compilers that support it. Otherwise, this will evaluate to nothing on non-Intel platforms.

For non Intel platforms, this resolves into a blank #define.

See also

BURGER_ANSIAPI or BURGER_FASTCALLENABLED

BURGER_APPLETALK

#define BURGER_APPLETALK

Define for the presence of AppleTalk.

---

If this define exists, then the AppleTalk networking protocol is supported. This is usually found on older MacOS computers and some Windows XP platforms.

See also

BURGER_TCPIP, BURGER_IPX, BURGER_STEAM, or BURGER_XBOXLIVE

BURGER_ARM

#define BURGER_ARM

Define to determine if code is being built for Advanced RISC Machine processors.

---

If this define exists, then you are creating code that runs on the Advanced RISC Machines line of processors.

See also

BURGER_ARM32 or BURGER_ARM64

BURGER_ARRAYSIZE

#define BURGER_ARRAYSIZE

(

x

)

Value:

static_cast<uintptr_t>(sizeof(*_BurgerArraySize(x)))

Define to return the number of elements in an array.

---

For arrays where the size is known at compile time, this macro will return the number of elements found in the array

Parameters

x	Name of the array to determine the size

int Foo[100];
 
// Will equal to 100
int ElementsInFoo = BURGER_ARRAYSIZE(Foo);

See also

_BurgerArraySize

BURGER_ASM

#define BURGER_ASM   asm

"C" compiler keyword for inline assembly.

---

No one could agree on what would the keyword be to start a block of inline assembly. This will map to asm or _asm depending on the compiler.

It's preferred that this keyword is used for Intel assembly.

See also

BURGER_DECLSPECNAKED or BURGER_ANSIAPI

BURGER_ASSERT

#define BURGER_ASSERT

(

conditional

)

Value:

    ((conditional) ? static_cast<void>(0) : \
                     static_cast<void>( \
                         ::Burger::Assert(#conditional, __FILE__, __LINE__)))

Invoke the debugger when a condition is met only when _DEBUG is defined.

---

Note

On Release builds with NDEBUG defined, this macro will perform no action and generate no code so the conditional will never be tested

Parameters

conditional

A boolean that evaluates to FALSE to call the assert function Burger::Assert(const char *,const char *,uint32_t)

See also

BURGER_ASSERTTEST or Burger::Assert(const char *,const char *,uint32_t)

BURGER_ASSERTTEST

#define BURGER_ASSERTTEST

(

conditional

)

Value:

    ((conditional) ? TRUE : ::Burger::Assert(#conditional, __FILE__, __LINE__))

Always test a condition and if it's false, invoke the debugger.

---

Parameters

conditional

A boolean that evaluates to FALSE to call the assert function Burger::Assert(const char *,const char *,uint32_t)

Note

This macro will always invoke the conditional and will return the boolean of TRUE or FALSE in Release builds. If it's executing a Debug build, the Burger::Assert( const char ,const char,uint32_t) function is called if the conditional evaluates to FALSE

Returns

The boolean evaluation of the conditional.

See also

BURGER_ASSERT or Burger::Assert(const char *,const char *,uint32_t)

BURGER_AVX

#define BURGER_AVX

Define to determine if code is being built for AVX instruction set extensions.

---

If this define exists, then you are creating code that runs a processor that has AVX instructions.

Click here to read the SSE through AVX2 instruction set

See also

BURGER_3DNOW, BURGER_SSE, BURGER_SSE2, BURGER_AVX2, BURGER_INTEL, BURGER_X86, or BURGER_AMD64

BURGER_AVX2

#define BURGER_AVX2

Define to determine if code is being built for AVX2 instruction set extensions.

---

If this define exists, then you are creating code that runs a processor that has AVX2 instructions.

Click here to read the SSE through AVX2 instruction set

See also

BURGER_3DNOW, BURGER_SSE, BURGER_SSE2, BURGER_AVX, BURGER_INTEL, BURGER_X86, or BURGER_AMD64

BURGER_BIGENDIAN

#define BURGER_BIGENDIAN

Define to flag code running on a big endian machine.

---

This define or BURGER_LITTLEENDIAN will be present to allow the programmer to create code that can properly parse endian specific data. Only one macro will be defined.

If this macro is present, the machine the code is being built for is big endian.

See also

BURGER_LITTLEENDIAN, BURGER_ENDIANINDEX_LOW or BURGER_ENDIANINDEX_HIGH

BURGER_BIGENDIAN16

#define BURGER_BIGENDIAN16

(

x

)

Value:

(x)

Endian swaps a 16 bit constant on little endian machines.

---

If a constant is required to exist as big endian, this macro will perform the endian swap at compile time if the machine is little endian.

Parameters

x	16 bit constant

Returns

Constant in big endian format.

See also

BURGER_BIGENDIAN32() or BURGER_LITTLEENDIAN16()

BURGER_BIGENDIAN32

#define BURGER_BIGENDIAN32

(

x

)

Value:

(x)

Endian swaps a 32 bit constant on little endian machines.

---

If a constant is required to exist as big endian, this macro will perform the endian swap at compile time if the machine is little endian.

Parameters

x	32 bit constant

Returns

Constant in big endian format.

See also

BURGER_BIGENDIAN16() or BURGER_LITTLEENDIAN32()

BURGER_CONSOLE

#define BURGER_CONSOLE

Define for the presence of a text console.

---

If this define exists, then the platform supports a terminal console such as CMD.COM, bash, sh etc. Test for this macro if the code requires a console, such as code for a command line tool.

See also

BURGER_MSDOS, BURGER_LINUX, BURGER_MACOS or BURGER_WINDOWS

BURGER_CONST_GET_BASE_PTR

#define BURGER_CONST_GET_BASE_PTR	(		x,
			__type,
			__member )

Value:

    reinterpret_cast<const __type*>(reinterpret_cast<const uint8_t*>(x) - \
        BURGER_OFFSETOF(__type, __member))

Define to return the const base pointer of a class from a class member.

---

Return the const pointer to the parent class a member variable resides.

Parameters

x	Const pointer to the member variable that needs fix up
__type	Name of the class / struct type
__member	Name of the member in the type to determine the offset of.

struct foo {
    int m_member;
    int m_member2;
};
 
struct bar {
    int m_Temp;
    int m_Temp2;
    foo m_Foo;
};
 
// Structure to work with
bar Test;
 
// Get pointer to a member variable
const foo *pFoo = &Test;
 
// Use the macro to convert the member pointer back into a bar *
const bar *pBar = BURGER_CONST_GET_BASE_PTR(pFoo,bar,m_Foo);

See also

BURGER_OFFSETOF, BURGER_GET_BASE_PTR

BURGER_CONSTEXPR

#define BURGER_CONSTEXPR   constexpr

Defined to nothing if constexpr is not supported.

---

On compilers that support the keyword constexpr, this define will be set to constexpr, otherwise this define will be defined to nothing.

// Foo is code that can generate a runtime constant
// with this keyword. If the input values are
// constants, the entire function will be optimized
// away and a new constant will be created
 
BURGER_CONSTEXPR int Foo(int a,int b)
{
    return a*b;
}
 
void Sample(void)
{
    // This will compile to iNewConstant = 6 on C++14 compilers
    // or a call to Foo(2,3) on older compilers that
    // don't perform Link Time Code Generation
 
    int iNewConstant = Foo(2,3);
}

See also

BURGER_CPP11, BURGER_FINAL, BURGER_OVERRIDE or nullptr

BURGER_CPP11

#define BURGER_CPP11   __cplusplus

Define to determine if compiler has feature level C++11.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++11 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP98, BURGER_CPP14, BURGER_CPP17, BURGER_CPP20, and BURGER_CPP23

BURGER_CPP14

#define BURGER_CPP14   __cplusplus

Define to determine if compiler has feature level C++14.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++14 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP98, BURGER_CPP11, BURGER_CPP17, BURGER_CPP20, and BURGER_CPP23

BURGER_CPP17

#define BURGER_CPP17   __cplusplus

Define to determine if compiler has feature level C++17.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++17 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP98, BURGER_CPP11, BURGER_CPP14, BURGER_CPP20, and BURGER_CPP23

BURGER_CPP20

#define BURGER_CPP20   __cplusplus

Define to determine if compiler has feature level C++20.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++20 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP98, BURGER_CPP11, BURGER_CPP14, BURGER_CPP17, and BURGER_CPP23

BURGER_CPP23

#define BURGER_CPP23   __cplusplus

Define to determine if compiler has feature level C++23.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++23 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP98, BURGER_CPP11, BURGER_CPP14, BURGER_CPP17, and BURGER_CPP20

BURGER_CPP89

#define BURGER_CPP89   __cplusplus

Define to determine if compiler has feature level C++89 (ANSI C)

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in ANSI C++ compilers.

Note

Burgerlib requires this as a baseline. It will likely not compile using a compiler that isn't at least ANSI C89 level of compatibility.

See also

BURGER_STDCPP_NAME, BURGER_CPP98, BURGER_CPP11, BURGER_CPP14, BURGER_CPP17, BURGER_CPP20, and BURGER_CPP23

BURGER_CPP98

#define BURGER_CPP98   __cplusplus

Define to determine if compiler has feature level C++98.

---

If this define exists, then you are creating code with a compiler that has a minimum feature set found in C++98 compilers.

See also

BURGER_STDCPP_NAME, BURGER_CPP89, BURGER_CPP11, BURGER_CPP14, BURGER_CPP17, BURGER_CPP20, and BURGER_CPP23

BURGER_CREATE_STATICRTTI_BASE

#define BURGER_CREATE_STATICRTTI_BASE

(

__ClassName

)

Value:

    const Burger::StaticRTTI* __ClassName::get_StaticRTTI(void) \
        const BURGER_NOEXCEPT \
    { \
        return &g_StaticRTTI; \
    } \
    const Burger::StaticRTTI __ClassName::g_StaticRTTI = {#__ClassName, nullptr}

Define to create a StaticRTTI for a base class.

---

For a class that's not derived from anything, use this macro to generate a terminating linked list entry

Parameters

__ClassName

Class name (No quotes)

See also

Burger::StaticRTTI, BURGER_RTTI_IN_CLASS or BURGER_CREATE_STATICRTTI_PARENT

BURGER_CREATE_STATICRTTI_PARENT

#define BURGER_CREATE_STATICRTTI_PARENT	(		__ClassName,
			__ParentClass )

Value:

    const Burger::StaticRTTI* __ClassName ::get_StaticRTTI(void) \
        const BURGER_NOEXCEPT \
    { \
        return &g_StaticRTTI; \
    } \
    const Burger::StaticRTTI __ClassName::g_StaticRTTI = { \
        #__ClassName, &__ParentClass::g_StaticRTTI}

Define to create a StaticRTTI for a derived class.

---

For a class that's derived, use this macro to generate a linked list entry that connects to its parent

Parameters

__ClassName	Class name (No quotes)
__ParentClass	Parent class name (No quotes)

See also

Burger::StaticRTTI, BURGER_RTTI_IN_CLASS or BURGER_CREATE_STATICRTTI_BASE

BURGER_DARWIN

#define BURGER_DARWIN

Define to determine if code is being built on a Darwin platorm.

---

If this define exists, then the code is running on macOS X, tvOS, watchOS, or iOS running on top of Darwin.

See also

BURGER_IOS, or BURGER_MACOSX

BURGER_DECLSPECNAKED

#define BURGER_DECLSPECNAKED   __declspec(naked)

"C" compiler keyword for a pure assembly function.

---

No one could agree on what would the keyword be to declare a "C" function that is 100% assembly. This will map to asm or __declspec(naked) depending on the compiler.

It's preferred that this keyword is used for Intel assembly only.

Note

Use of this keyword implies that there is no "C" glue code so setup, tear down and exiting must all be present in the assembly code.

BURGER_DECLSPECNAKED uint32_t BURGER_API SwapEndian(uint32_t Val)
{
    BURGER_ASM {
        mov     eax,ecx
        bswap   eax
        ret
    }
}

See also

BURGER_X86 or BURGER_FASTCALLENABLED

BURGER_DEFAULT_CONSTRUCTOR

#define BURGER_DEFAULT_CONSTRUCTOR   BURGER_NOEXCEPT = default

Declare "= default" on C++ 11 compilers.

---

For a default constructor, "= default" is the preferred method for C++ 11 or higher compilers, while earlier compilers prefer {} for default constructors. This macro will expand to the preferred format for creating default constructors.

\code
class DefaultClass {
    // Default constructor
    DefaultClass() BURGER_DEFAULT_CONSTRUCTOR;

public:
    void DoStuff(void);

\endcode

\sa BURGER_EQUALS_DEFAULT or BURGER_DEFAULT_DESTRUCTOR

BURGER_DEFAULT_DESTRUCTOR

#define BURGER_DEFAULT_DESTRUCTOR   = default

Declare "= default" on C++ 11 compilers.

---

For a default destructor, "= default" is the preferred method for C++ 11 or higher compilers, while earlier compilers prefer {} for default destructors. This macro will expand to the preferred format for creating default destructors.

class DefaultClass {
    // Default destructor
    ~DefaultClass() BURGER_DEFAULT_DESTRUCTOR;
 
public:
    void DoStuff(void);

See also

BURGER_DEFAULT_CONSTRUCTOR, BURGER_EQUALS_DEFAULT or BURGER_EQUALS_DELETE

BURGER_DISABLE_ASAN

#define BURGER_DISABLE_ASAN   __attribute__((no_sanitize_address))

Disable address sanitization.

---

If the code is being built with Address Sanitization, this macro will disable testing any function that is marked. It's to work around false positives.

See also

BURGER_ADDRESS_SANITIZER, BURGER_DISABLE_MSAN or BURGER_CLANG

BURGER_DISABLE_COPY

#define BURGER_DISABLE_COPY

(

x

)

Value:

private: \
    x(const x&) BURGER_EQUALS_DELETE; \
    x& operator=(const x&) BURGER_EQUALS_DELETE; \
    x(x&&) BURGER_EQUALS_DELETE; \
    x& operator=(x&&) BURGER_EQUALS_DELETE

Declares copy constructors to disable invocation at runtime.

---

Some classes by their nature shouldn't be or can't be copied, by declaring this macro, the x(x const &) constructor and the x &operator = (x const &) operator are declared. If compiled with C++11 or higher, the x(x &&) and x& operator = (x &&) are also declared as '= delete'.

Note

This macro MUST be invoked in a private section of a class or it will inadvertently declare that there are copy constructors in existence which could lead to mysterious link errors.

Parameters

x	Name of the class that the macro resides in

class DontCopyMe {
    // Disallow copying of this class
    BURGER_DISABLE_COPY(DontCopyMe);
public:
    void DoStuff(void);

Note

This macro will set the class setting to "private"

See also

BURGER_EQUALS_DELETE

BURGER_DISABLE_MSAN

#define BURGER_DISABLE_MSAN   __attribute__((no_sanitize("memory")))

Disable memory sanitization.

---

If the code is being built with Memory Sanitization, this macro will disable testing any function that is marked. It's to work around false positives.

See also

BURGER_MEMORY_SANITIZER, BURGER_DISABLE_ASAN or BURGER_CLANG

BURGER_ENDIANINDEX_HIGH

#define BURGER_ENDIANINDEX_HIGH   (1 - BURGER_ENDIANINDEX_LOW)

Index to the "high" word of a 64 bit value as a 32 value.

---

On little endian machines, this value is 1, otherwise it's 0.

See also

BURGER_ENDIANINDEX_LOW, BURGER_LITTLEENDIAN or BURGER_BIGENDIAN

BURGER_ENDIANINDEX_LOW

#define BURGER_ENDIANINDEX_LOW   1

Index to the "low" word of a 64 bit value as a 32 value.

---

On little endian machines, this value is 0, otherwise it's 1.

See also

BURGER_ENDIANINDEX_HIGH, BURGER_LITTLEENDIAN or BURGER_BIGENDIAN

BURGER_ENUM_CLASS_END

#define BURGER_ENUM_CLASS_END

(

x

)

Finish a cross platform "enum class : int {" instance.

---

This macro maps to "}; } typedef x::Type x ## Type;" on older compilers.

Parameters

x	Name of the new enum (Must match the name used in preceding BURGER_ENUM_CLASS_START(x)

Note

Read the description of BURGER_ENUM_CLASS_START for full details.

// Declare eTestEnum members and the eTestEnumType
 
BURGER_ENUM_CLASS_START(eTestEnum,uint_t) {
    value0,
    value1,
    value2
} BURGER_ENUM_CLASS_END(eTestEnum)
 
// Call this function with the global enum type of eTestEnumType
 
void foo(eTestEnumType uValue)
{
    // Test each value with eTestEnum:: prefixes
    switch (uValue) {
    case eTestEnum::value0:
        printf("value0\n");
        break;
    case eTestEnum::value1:
        printf("value1\n");
        break;
    case eTestEnum::value0:
        printf("value2\n");
        break;
    }
}

See also

BURGER_ENUM_CLASS_START and BURGER_ENUM_CLASS_END_MATH

BURGER_ENUM_CLASS_END_MATH

#define BURGER_ENUM_CLASS_END_MATH	(		x,
			y )

Value:

    BURGER_ENUM_CLASS_END(x); \
    BURGER_ENUM_MATH(x, y)

Finish a cross platform "enum class : int {" instance for flags.

---

This macro will invoke BURGER_ENUM_CLASS_END and then add a list of operator overloads so the bit values can be merged and tested with strong type safety.

Binary operators that are considered valid for flags are AND (&), OR (|) and XOR (^) and unary operations NOT (!) and bitwise XOR (~).

The operation overload will enforce the data type declared for the enum, so operators such as bitwise XOR (~) will only be as wide as the declared underlying type.

Note

Read the description of BURGER_ENUM_CLASS_START for full details.

Parameters

x	Name of the new enum (Must match the name used in preceding BURGER_ENUM_CLASS_START(z)
y	Desired data type for the new enum

// Declare eTestFlags members and the eTestFlagsType
 
BURGER_ENUM_CLASS_START(eTestFlags,Byte) {
    None=0,                 // No flag present
    Flag1 = 0x01,           // First bit flag
    Flag2 = 0x02,           // Second bit flag
    Flag3 = 0x04            // You get the drift
} BURGER_ENUM_CLASS_END_MATH(eTestFlags,Byte)
 
// Call this function with the global enum type of eTestFlagsType
 
void foo(eTestFlagsType uFlags)
{
    // A flag was set?
    if (uFlags!=eTestFlags::None) {
        // Test the flags and print
        if ((uFlags&eTestFlags::Flag1)!=eTestFlags::None) {
            printf("Flag1 found\n");
        }
        if ((uFlags&eTestFlags::Flag2)!=eTestFlags::None) {
            printf("Flag2 found\n");
        }
        if ((uFlags&eTestFlags::Flag3)!=eTestFlags::None) {
            printf("Flag3 found\n");
        }
        if ((uFlags&(eTestFlags::Flag2|eTestFlags::Flag3))!=
            eTestFlags::None) {
            printf("Flag2 or Flag3 found\n");
        }
        if ((uFlags&(eTestFlags::Flag2|eTestFlags::Flag3))==
            (eTestFlags::Flag2|eTestFlags::Flag3)) {
            printf("Flag2 and Flag3 found\n");
        }
    }
}
 
void bar(void)
{
    foo(eTestFlags::None);
    foo(eTestFlags::Flag2);
    foo(eTestFlags::Flag2|eTestFlags::Flag3);
}

See also

BURGER_ENUM_CLASS_START and BURGER_ENUM_CLASS_END_MATH

BURGER_ENUM_CLASS_START

#define BURGER_ENUM_CLASS_START	(		x,
			y )

Value:

enum class x : y

Creates a cross platform "enum class : int {" instance.

---

This macro maps to "namespace x { enum Type {" on older compilers.

Newer compilers support strong enum types where it's impossible to test one enum type with another due to the implicit conversion to integer. This is called "enum class". This macro offers this support while still offering backwards compatibility with C89 and C99 compilers. The solution was to use "enum class" on compilers that support it, and use a namespace to encapsulate the enum members on older compilers (Or compilers that have extensions turned off).

There were compromises made, enums need to be generated with a start and end macro so they could ensure the members are either inside a namespace or an enum class. However, this caused a difference in the final type, with it either being a global type name or a name embedded in a namespace. To get around this, a unified type was generated called "???Type" where the ??? is replaces with the name of the new enum and it's declared as a typedef to either the enum class or "enum Type" that resides in the namespace.

Note

Always use the declared enum type to reference the members and ??? Type to declare the enum as a member variable or parameter. Secondly, the size of the data is only enforced on compilers that offer "enum class foo : char" or "enum foo : char" type declarations, otherwise, the compiler will likely map the enum to a signed integer.

Parameters

x	Name of the new enum
y	Desired data type for the new enum

// Declare eTestEnum members and the eTestEnumType
 
BURGER_ENUM_CLASS_START(eTestEnum,uint_t) {
    value0,
    value1,
    value2
} BURGER_ENUM_CLASS_END(eTestEnum)
 
// Call this function with the global enum type of eTestEnumType
 
void foo(eTestEnumType uValue)
{
    // Test each value with eTestEnum:: prefixes
    switch (uValue) {
    case eTestEnum::value0:
        printf("value0\n");
        break;
    case eTestEnum::value1:
        printf("value1\n");
        break;
    case eTestEnum::value0:
        printf("value2\n");
        break;
    }
}

See also

BURGER_ENUM_TYPE, BURGER_ENUM_CLASS_END and BURGER_ENUM_CLASS_END_MATH

BURGER_ENUM_MATH

#define BURGER_ENUM_MATH	(		x,
			y )

Value:

BURGER_INLINE x& operator|=(x& uInput1, x uInput2) BURGER_NOEXCEPT { \
    return uInput1 = static_cast<x>(static_cast<y>(uInput1) | static_cast<y>(uInput2)); } \
BURGER_INLINE x& operator&=(x& uInput1, x uInput2) BURGER_NOEXCEPT { \
    return uInput1 = static_cast<x>(static_cast<y>(uInput1) & static_cast<y>(uInput2)); } \
BURGER_INLINE x& operator^=(x& uInput1, x uInput2) BURGER_NOEXCEPT { \
    return uInput1 = static_cast<x>(static_cast<y>(uInput1) ^ static_cast<y>(uInput2)); } \
BURGER_INLINE BURGER_CONSTEXPR x operator|(x uInput1, x uInput2) BURGER_NOEXCEPT { \
    return static_cast<x>(static_cast<y>(uInput1) | static_cast<y>(uInput2)); } \
BURGER_INLINE BURGER_CONSTEXPR x operator&(x uInput1, x uInput2) BURGER_NOEXCEPT { \
    return static_cast<x>(static_cast<y>(uInput1) & static_cast<y>(uInput2)); } \
BURGER_INLINE BURGER_CONSTEXPR x operator^(x uInput1, x uInput2) BURGER_NOEXCEPT { \
    return static_cast<x>(static_cast<y>(uInput1) ^ static_cast<y>(uInput2)); } \
BURGER_INLINE BURGER_CONSTEXPR uint_t operator!(x uInput) BURGER_NOEXCEPT { \
    return !static_cast<y>(uInput); } \
BURGER_INLINE BURGER_CONSTEXPR x operator~(x uInput) BURGER_NOEXCEPT { \
    return static_cast<x>(~static_cast<y>(uInput)); }

Create math functions to handle an enum.

---

This macro will create a list of operator overloads so the bit values can be merged and tested with strong type safety.

Binary operators that are considered valid for flags are AND (&), OR (|) and XOR (^) and unary operations NOT (!) and bitwise XOR (~).

The operation overload will enforce the data type declared for the enum, so operators such as bitwise XOR (~) will only be as wide as the declared underlying type.

Note

Read the description of BURGER_ENUM_CLASS_START for full details.

Parameters

x	Name of the enum to accept as input.
y	Data type of the enum, must match the type used on the enum's declaration.

// Declare eTestFlags members and the eTestFlagsType
 
BURGER_ENUM_TYPE(eTestFlags, uint8_t) {
    None=0,                 // No flag present
    Flag1 = 0x01,           // First bit flag
    Flag2 = 0x02,           // Second bit flag
    Flag3 = 0x04            // You get the drift
};
 
BURGER_ENUM_MATH(eTestFlags, uint8_t)
 
// Call this function with the enum
 
void foo(eTestFlags uFlags)
{
    // A flag was set?
    if (uFlags!=None) {
        // Test the flags and print
        if ((uFlags&Flag1)!=None) {
            printf("Flag1 found\n");
        }
        if ((uFlags&Flag2)!=None) {
            printf("Flag2 found\n");
        }
        if ((uFlags&Flag3)!=None) {
            printf("Flag3 found\n");
        }
        if ((uFlags&(Flag2|Flag3))!=None) {
            printf("Flag2 or Flag3 found\n");
        }
        if ((uFlags&(Flag2|Flag3))==(Flag2|Flag3)) {
            printf("Flag2 and Flag3 found\n");
        }
    }
}
 
void bar(void)
{
    foo(None);
    foo(Flag2);
    foo(Flag2|Flag3);
}

See also

BURGER_ENUM_TYPE and BURGER_ENUM_CLASS_END_MATH

BURGER_ENUM_TYPE

#define BURGER_ENUM_TYPE	(		x,
			y )

Value:

enum x : y

Creates a cross platform enum eSample : uint32_t { instance.

---

This macro maps to enum eSample { on older compilers.

Newer compilers support enum types where the data type can be declared for space or sign. Older compilers declare enum as int or data type size. To allow the usage of the enum eSample : int {, use this macro.

Note

The enum is unscoped, hence all members are declared in the current namespace.

Parameters

x	Name of the new enum
y	Desired data type for the new enum on modern compilers

// Declare eTestEnum members taking uint_t size.
 
BURGER_ENUM_TYPE(eTestEnum, uint_t) {
    VALUE0,
    VALUE1,
    VALUE2
};
 
// Call this function with the declared enum type of eTestEnum
 
void foo(eTestEnum uValue)
{
    // Test each value with eTestEnum:: prefixes
    switch (uValue) {
    case VALUE0:
        printf("VALUE0\n");
        break;
    case VALUE1:
        printf("VALUE1\n");
        break;
    case VALUE0:
        printf("VALUE2\n");
        break;
    }
}

See also

BURGER_ENUM_CLASS_START and BURGER_ENUM_MATH

BURGER_EQUALS_DEFAULT

#define BURGER_EQUALS_DEFAULT   = default

Declare "= default" on C++ 11 compilers.

---

Some default constructors can be created in C++11 by the use of the term "= default" suffix. Of the compiler supports this feature, this macro will map to "= default", otherwise the macro will be blank.

class DefaultClass {
    // Default constructor
    DefaultClass() BURGER_EQUALS_DEFAULT;
 
public:
    void DoStuff(void);

See also

BURGER_EQUALS_DELETE or BURGER_DEFAULT_DESTRUCTOR

BURGER_EQUALS_DELETE

#define BURGER_EQUALS_DELETE   = delete

Declare "= delete" on C++ 11 compilers.

---

Some class functions can be disabled in C++11 by the use of the term "= delete" suffix. Of the compiler supports this feature, this macro will map to "= delete", otherwise the macro will be blank.

class DontCopyMe {
    // Disallow copying of this class
    DontCopyMe(const &) BURGER_EQUALS_DELETE;
    DontCopyMe& operator=(DontCopyMe const&) BURGER_EQUALS_DELETE;
public:
    void DoStuff(void);

See also

BURGER_DISABLE_COPY, or BURGER_EQUALS_DEFAULT

BURGER_EXPAND_FORMATTING_FUNCTION

#define BURGER_EXPAND_FORMATTING_FUNCTION

(

F

)

Value:

    F(1) \
    F(2) \
    F(3) \
    F(4) \
    F(5) \
    F(6) \
    F(7) \
    F(8) \
    F(9) \
    F(10) \
    F(11) \
    F(12) \
    F(13) F(14) F(15) F(16) F(17) F(18) F(19) F(20) F(21) F(22) F(23) F(24)

Function to generate SafePrint functions.

---

To invoke SafePrint via a parameter list, it's necessary to fake the ability to do the "C" ... style parameter passing. To handle this, generate a code fragment that will create the argument table and then call the SafePrint functions and this macro will create 24 functions that handle 1 through 24 parameters.

BURGER_FALLTHROUGH

#define BURGER_FALLTHROUGH   [[fallthrough]]

Mark with [[fallthrough]].

---

For C++17 or higher compilers, or those that support the equivalent, insert the [[fallthrough]] attribute to the code.

See also

BURGER_NODISCARD or BURGER_MAYBE_UNUSED

BURGER_FINAL

#define BURGER_FINAL   final

Defined to nothing if the feature is not available.

---

On compilers that support final, this macro is set to final. To support this feature on older compilers, this macro is set to nothing.

Microsoft Visual C can set this to sealed, or for GNU compilers it is set to __final.

See also

BURGER_CPP11, nullptr, BURGER_OVERRIDE or BURGER_CONSTEXPR

BURGER_FIXED_TO_FLOAT

#define BURGER_FIXED_TO_FLOAT

(

x

)

Value:

(static_cast<float>(x) * (1.0f / 65536.0f))

Define to convert a Fixed32 into a float.

---

Macro to convert at compile time a 16.16 fixed point number into a floating point value Used for compile assignment of float constants using Fixed32 constants..

Note

Due to the integer to float conversion, use of this macro at runtime on non constant values may be a performance penalty on the Xbox 360 and PS3.

// Fast use
static const float MyData = BURGER_FIXED_TO_FLOAT(Burger::kPiFixed32);
// Slow use
void Foo(Fixed32 iInput)
{
    float fInput = BURGER_FIXED_TO_FLOAT(iInput);
}

Parameters

x	16.16 fixed point value to convert to a float.

BURGER_FIXED_TO_INT

#define BURGER_FIXED_TO_INT

(

x

)

Value:

    static_cast<int>((x + ((x >> 31) & 0xFFFF)) >> 16)

Define to convert a Fixed32 value to an integer.

---

Macro to convert at compile time a 16.16 fixed point value into an integer. Used for compile time assignment of integers using Fixed32 constants.

Note

This macro uses round to zero in the removal of the fraction. Negative numbers like -0.8 become 0, as well as 0.8 becomes 0.

static const int MyData = BURGER_FIXED_TO_INT(Burger::kPiFixed32);

Parameters

x	Fixed32 value to convert to an integer.

BURGER_FLOAT_TO_FIXED

#define BURGER_FLOAT_TO_FIXED

(

x

)

Value:

static_cast<Fixed32>((x)*65536.0f)

Define to convert a float into a Fixed32.

---

Macro to convert at compile time a floating point value into 16.16 fixed point. Used for compile assignment of Fixed32 constants.

Note

Due to the float to integer conversion, use of this macro at runtime may be a performance penalty on the Xbox 360 and PS3 on non-constant values.

// Fast use
static const Fixed32 MyData = BURGER_FLOAT_TO_FIXED(4.503f);
// Slow use
void Foo(float fInput)
{
    Fixed32 iInput = BURGER_FLOAT_TO_FIXED(fInput);
}

Parameters

x	Floating point value to convert to a Fixed32.

BURGER_GET_BASE_PTR

#define BURGER_GET_BASE_PTR	(		x,
			__type,
			__member )

Value:

    reinterpret_cast<__type*>( \
        reinterpret_cast<uint8_t*>(x) - BURGER_OFFSETOF(__type, __member))

Define to return the base pointer of a class from a class member.

---

Return the pointer to the parent class a member variable resides.

Parameters

x	Pointer to the member variable that needs fix up
__type	Name of the class / struct type
__member	Name of the member in the type to determine the offset of.

struct foo {
    int m_member;
    int m_member2;
};
 
struct bar {
    int m_Temp;
    int m_Temp2;
    foo m_Foo;
};
 
// Structure to work with
bar Test;
 
// Get pointer to a member variable
foo *pFoo = &Test;
 
// Use the macro to convert the member pointer back into a bar *
bar *pBar = BURGER_GET_BASE_PTR(pFoo,bar,m_Foo);

See also

BURGER_OFFSETOF, BURGER_CONST_GET_BASE_PTR

BURGER_HALF_EPSILON

#define BURGER_HALF_EPSILON   static_cast<float16_t>(0x1400U)

Smallest positive difference between 16 bit float values.

BURGER_HALF_MAX

#define BURGER_HALF_MAX   static_cast<float16_t>(0x7BFFU)

Largest value stored in a 16 bit float.

BURGER_HALF_MIN

#define BURGER_HALF_MIN   static_cast<float16_t>(0x0001U)

Smallest value for a 16 bit float.

BURGER_HALF_NEG_INF

#define BURGER_HALF_NEG_INF   static_cast<float16_t>(0xFC00U)

16 bit float negative infinity

BURGER_HALF_NRM_MIN

#define BURGER_HALF_NRM_MIN   static_cast<float16_t>(0x0400U)

Smallest normalized value for a 16 bit float.

BURGER_HALF_POS_INF

#define BURGER_HALF_POS_INF   static_cast<float16_t>(0x7C00U)

16 bit float positive infinity

BURGER_HALF_QNAN

#define BURGER_HALF_QNAN   static_cast<float16_t>(0x7FFFU)

16 bit float QNAN

BURGER_HALF_SNAN

#define BURGER_HALF_SNAN   static_cast<float16_t>(0x7DFFU)

16 bit float SNAN

BURGER_HAS_64_BIT_SUPPORT

#define BURGER_HAS_64_BIT_SUPPORT

Computer supports 64 bit integers.

---

Most compilers support 64 bit integers, but older compilers only support 32 bit integers. To allow limited 64 bit integer support, this define exists and Burger::longlong_t and Burger::ulonglong_t are used to preform 64 bit integer math.

See also

Burger::longlong_t, or Burger::ulonglong_t

BURGER_HAS_CHAR16_T

#define BURGER_HAS_CHAR16_T

Data type char16_t and char32_t are native.

---

If this define is present, char16_t and char32_t are a native types for the compiler.

See also

BURGER_CPP11, BURGER_HAS_CHAR8_T or BURGER_HAS_WCHAR_T

BURGER_HAS_CHAR8_T

#define BURGER_HAS_CHAR8_T

Data type char8_t is native.

---

If this define is present, char8_t is a native type for the compiler.

See also

BURGER_CPP20, BURGER_HAS_WCHAR_T or BURGER_HAS_CHAR16_T

BURGER_HAS_SFINAE

#define BURGER_HAS_SFINAE

Compiler supports SFINAE.

---

Most compilers support "Substitution Failure Is Not An Error" (SFINAE), for those few old compilers that don't support it, this macro doesn't exist.

BURGER_HAS_WCHAR_T

#define BURGER_HAS_WCHAR_T

Data type wchar_t is native.

---

If this define is present, wchar_t is a native type for the compiler, otherwise, it's a typedef cast from an unsigned short, which may cause collisions for classes that want to treat wchar_t and uint16_t as unique data types.

See also

BURGER_HAS_CHAR8_T or BURGER_HAS_CHAR16_T

BURGER_INLINE

#define BURGER_INLINE   inline

Define to create inline code.

---

Since pre-C++ compilers created different keywords to force inlining of a function, this define standardizes the keyword. Normally, it will evaluate to inline, but it can become __inline or __forceinline or some other token that is compiler specific.

In all cases, the behavior of the C++ inline keyword is what is expected.

See also

BURGER_NO_INLINE or BURGER_NORETURN

BURGER_INT_TO_FIXED

#define BURGER_INT_TO_FIXED

(

x

)

Value:

static_cast<Fixed32>((x) << 16)

Define to convert a integer into a Fixed32.

---

Macro to convert at compile time an integer value into 16.16 fixed point. Used for compile assignment of Fixed32 constants.

Note

There is no bounds checking performed by this macro. As a result, integers larger than 32767 or less than -32768 will cause undefined behavior due to over/underflow.

static const Fixed32 MyData = BURGER_INT_TO_FIXED(443);

Parameters

x	Integer value to convert to a Fixed32.

BURGER_INTEL

#define BURGER_INTEL

Define to determine if the CPU is either X86 or AMD64.

---

On BURGER_AMD64 or BURGER_X86 CPUs, this define will also be present to allow Intel Architecture instructions. Some instructions may or may not be present, so call Burger::CPUID(Burger::CPUID_t *) to test for all features and determine which functions to use for performance.

See also

BURGER_XBOXONE, BURGER_PS4, BURGER_PS5, BURGER_WINDOWS, BURGER_MACOSX, BURGER_X86, or BURGER_AMD64

BURGER_INVALID_SOCKET

#define BURGER_INVALID_SOCKET   UINTPTR_MAX

BURGER_IPX

#define BURGER_IPX

Define for the presence of IPX/SPX.

---

If this define exists, then the IPX/SPX networking protocol is supported. It's supported on Windows and older MacOS platforms.

See also

BURGER_TCPIP, BURGER_APPLETALK, BURGER_STEAM, or BURGER_XBOXLIVE

BURGER_JOIN

#define BURGER_JOIN	(		x,
			y )

Value:

BURGER_JOIN2(x, y)

Concatenates two strings, even if they are macros.

---

Using deep magic in the form of BURGER_JOIN2 and BURGER_JOIN3, join the two macros into one.

Parameters

x	The first macro to join.
y	The second macro to join.

See also

BURGER_JOIN2 or BURGER_JOIN3

BURGER_JOIN2

#define BURGER_JOIN2	(		x,
			y )

Value:

BURGER_JOIN3(x, y)

Invokes BURGER_JOIN3.

---

Invoke BURGER_JOIN3 to join macros with ##.

Parameters

x	The first macro to join.
y	The second macro to join.

See also

BURGER_JOIN or BURGER_JOIN3

BURGER_JOIN3

#define BURGER_JOIN3	(		x,
			y )

Value:

x##y

Combine two macros with ##.

---

Use ## to join two macros.

Parameters

x	The first macro to join.
y	The second macro to join.

See also

BURGER_JOIN or BURGER_JOIN2

BURGER_LEFT_PARENTHESIS

#define BURGER_LEFT_PARENTHESIS   (

The character (.

---

If a macro contains a parenthesis, it will be treated as an enclosure for a parameter list. Use this macro inside another macro to output a left parenthesis without actually invoking parameters.

See also

BURGER_RIGHT_PARENTHESIS

BURGER_LITTLEENDIAN16

#define BURGER_LITTLEENDIAN16

(

x

)

Value:

(((x & 0xFFU) << 8U) + ((x >> 8U) & 0xFFU))

Endian swaps a 16 bit constant on big endian machines.

---

If a constant is required to exist as little endian, this macro will perform the endian swap at compile time if the machine is big endian.

Parameters

x	16 bit constant

Returns

Constant in little endian format.

See also

BURGER_LITTLEENDIAN32() or BURGER_BIGENDIAN16()

BURGER_LITTLEENDIAN32

#define BURGER_LITTLEENDIAN32

(

x

)

Value:

    (((x & 0xFFU) << 24U) + ((x << 8U) & 0xFF0000U) + ((x >> 8U) & 0xFF00U) + \
        ((x >> 24U) & 0xFFU))

Endian swaps a 32 bit constant on big endian machines.

---

If a constant is required to exist as little endian, this macro will perform the endian swap at compile time if the machine is big endian.

Parameters

x	32 bit constant

Returns

Constant in little endian format.

See also

BURGER_LITTLEENDIAN16() or BURGER_BIGENDIAN32()

BURGER_LN10

#define BURGER_LN10   (2.3025850929940456840179914547)

ln(10.0) as a double

BURGER_LN2

#define BURGER_LN2   (0.69314718055994530941723212146)

ln(2.0) as a double

BURGER_LONG_NOT_IN_STDINT

#define BURGER_LONG_NOT_IN_STDINT

Is long used in stdint.h.

---

If this define is present, long isn't used in the int32_t family of data types, so if a series of functions wish to allow a function to be automatically called using long as a parameter, a function specifically using long as an input must be declared.

See also

BURGER_INT_NOT_IN_STDINT

BURGER_LONGLONG

#define BURGER_LONGLONG   Burger::longlong_t

Signed 64 bit integer type specific to the current compiler.

---

Define that has the compiler keyword that defines a 64 bit signed integer.

See also

BURGER_ULONGLONG

BURGER_MACOS

#define BURGER_MACOS

Define to determine if code is being built for any Apple Mac OS platform.

---

If this define exists, then you are creating code that runs under Apple MacOS. Currently, 68K, PowerPC and Intel are supported. Since it's not known which version of MacOS is currently being targeted, accessing the low memory operating system variables is NOT allowed.

See also

BURGER_POWERPC, BURGER_X86, BURGER_68K, BURGER_MACOSX, BURGER_MACCLASSIC, BURGER_MACCARBON or BURGER_MAC

BURGER_MAXINT

#define BURGER_MAXINT   0x7FFFFFFF

Maximum value of a signed integer.

---

This is a replacement for the ANSI macro MAX_INT. Normally, this is 0x7FFFFFFF, but it could be a 64 or 128 bit value on future processors.

See also

BURGER_MININT, BURGER_MAXINTPTR or BURGER_MAXUINT

BURGER_MAXINT64

#define BURGER_MAXINT64   0x7FFFFFFFFFFFFFFFLL

Maximum value of a int64_t.

---

This is a replacement for the ANSI macro MAX_INT but it's meant for 64 bit values defined as int64_t. Normally, this is 0x7FFFFFFFFFFFFFFFLL.

See also

BURGER_MININT64, BURGER_MAXUINT64, or BURGER_MAXINT

BURGER_MAXINTPTR

#define BURGER_MAXINTPTR   INTPTR_MAX

Maximum value of a signed address space integer.

---

This is a constant value of the largest allowable address. Normally, this is 0x7FFFFFFF on 32 bit CPUs and 0x7FFFFFFFFFFFFFFFLL on 64 bit CPUs. It may be a 128 bit value on future processors.

See also

BURGER_MAXINT or BURGER_MAXUINT

BURGER_MAXUINT

#define BURGER_MAXUINT   0xFFFFFFFFU

Maximum value of an unsigned integer.

---

This is a replacement for the ANSI macro MAX_UINT. Normally, this is 0xFFFFFFFFU, but it could be a 64 or 128 bit value on future processors.

See also

BURGER_MAXINTPTR or BURGER_MAXINT

BURGER_MAXUINT64

#define BURGER_MAXUINT64   0xFFFFFFFFFFFFFFFFULL

Maximum value of a uint64_t.

---

This is a replacement for the ANSI macro MAX_UINT but it's meant for 64 bit values defined as uint64_t. Normally, this is 0xFFFFFFFFFFFFFFFFULL.

See also

BURGER_MAXINT64, or BURGER_MAXUINT

BURGER_MAXWORDPTR

#define BURGER_MAXWORDPTR   UINTPTR_MAX

BURGER_MAYBE_UNUSED

#define BURGER_MAYBE_UNUSED   [[maybe_unused]]

Mark with [[maybe_unused]].

---

For C++17 or higher compilers, or those that support the equivalent, insert the [[maybe_unused]] attribute to the code.

See also

BURGER_NODISCARD, BURGER_USED or BURGER_FALLTHROUGH

BURGER_MEMORY_SANITIZER

#define BURGER_MEMORY_SANITIZER

Detect if memory sanitization is active.

---

If the code is being built with Memory Sanitization, this macro will exist.

See also

BURGER_DISABLE_MSAN or BURGER_CLANG

BURGER_MEMORYBARRIER

#define BURGER_MEMORYBARRIER

(

)

Value:

__asm__ __volatile__("" : : : "memory")

Invoke a memory barrier with the compiled code.

---

When writing multi-threaded code, sometimes it's necessary to instruct the compiler to not reorder read/write operations to ensure values are read or written as the code is listed on the source code.

Depending on compiler, this is a define or a function call.

In most cases, this generates no code, only an instruction to the compiler.

Note

Visual Studio maps to _ReadWriteBarrier()

BURGER_MININT

#define BURGER_MININT   ((-0x7FFFFFFF) - 1)

Minimum value of a signed integer.

---

This is a replacement for the ANSI macro MIN_INT. Normally, this is (-0x7FFFFFFF)-1, but it could be a 64 or 128 bit value on future processors.

See also

BURGER_MININT64 or BURGER_MAXINT

BURGER_MININT64

#define BURGER_MININT64   ((-0x7FFFFFFFFFFFFFFFLL) - 1)

Minimum value of a int64_t.

---

This is a replacement for the ANSI macro MIN_INT but it's meant for 64 bit values defined as int64_t. Normally, this is ((-0x7FFFFFFFFFFFFFFFLL)-1).

See also

BURGER_MAXINT64, BURGER_MAXUINT64, or BURGER_MAXINT

BURGER_MIPS

#define BURGER_MIPS

Define to determine if code is being built for MIPS processors.

---

If this define exists, then you are creating code that runs on the MIPS line of processors.

See also

BURGER_MIPS32 or BURGER_MIPS64

BURGER_MSVC_SUPPRESS

#define BURGER_MSVC_SUPPRESS

(

__T

)

Invoke #pragma warning(suppress:) in Microsoft Compilers.

---

Microsoft compilers are very thorough in finding issues with code, but sometimes it flags warnings on perfectly acceptable code. This macro will suppress the warning on the following line of code after this macro and then allow the warning to be invoked on the rest of the code.

Note

On non-Microsoft compilers, this macro does nothing.

Parameters

__T	Integer warning number to suppress

// Suppress the warning on the variable below
// Global initializer calls a non-constexpr function 'symbol'
BURGER_MSVC_SUPPRESS(26426)
 
// Init value on startup
static DWORD gStorage = TlsAlloc();

BURGER_NEON

#define BURGER_NEON

Define to determine if code is being built for Advanced RISC Machines NEON instruction set extensions.

---

If this define exists, then you are creating code that runs on the ARM line of processors with NEON instructions.

See also

BURGER_ARM, BURGER_ARM32, or BURGER_ARM64

BURGER_NO_INLINE

#define BURGER_NO_INLINE

Define to disable inline code.

---

Since pre-C++ compilers created different keywords to disable inlining of a function, this define standardizes the keyword. Normally, it will evaluate to __declspec(noinline), but it can become __attribute__((noinline)) or some other token that is compiler specific.

Some compilers don't support this keyword, for those compilers, this define resolves into nothing.

See also

BURGER_INLINE

BURGER_NODISCARD

#define BURGER_NODISCARD   [[nodiscard]]

Mark with [[nodiscard]].

---

For C++17 or higher compilers, or those that support the equivalent, insert the [[nodiscard]] attribute to the code.

See also

BURGER_MAYBE_UNUSED, BURGER_USED or BURGER_FALLTHROUGH

BURGER_NOEXCEPT

#define BURGER_NOEXCEPT   noexcept

Defined to nothing if noexcept is not supported.

---

On compilers that support the keyword noexcept, this define will be set to noexcept, otherwise this define will be defined to nothing.

See also

BURGER_CPP11, BURGER_FINAL, BURGER_OVERRIDE or nullptr

BURGER_NORETURN

#define BURGER_NORETURN   [[noreturn]]

Define to alert the compiler the function does not return.

---

Some compilers offer optimizations if it was aware that a function never returns. For functions that do not return, add this macro to the beginning of its definition to take advantage of this compiler feature.

See also

BURGER_INLINE

BURGER_NULL_MACRO_PARAM

#define BURGER_NULL_MACRO_PARAM

An empty macro parameter.

---

To trick the preprocessor to accept an empty parameter in a macro, use this macro which inserts a "C" style empty comment to force data separation so an empty parameter can be passed to a macro.

BURGER_OFFSETOF

#define BURGER_OFFSETOF	(		__type,
			__member )

Value:

    (reinterpret_cast<intptr_t>( \
         &reinterpret_cast<const __type*>(1)->__member) - \
        1)

Define to return the offset of a member variable.

---

Return the byte offset of a member variable from a class or struct.

Parameters

__type	Name of the class / struct type
__member	Name of the member in the type to determine the offset of.

struct foo {
    int m_member;
    int m_member2;
};
 
// Will equal to 4 (Usually)
int offsetofmember2 = BURGER_OFFSETOF(foo,m_member2);

See also

BURGER_GET_BASE_PTR

BURGER_OPENGL

#define BURGER_OPENGL

Define for the presence of OpenGL.

---

If this define exists, then OpenGL is supported.

See also

BURGER_OPENGLES, or BURGER_VULKAN

BURGER_OPENGLES

#define BURGER_OPENGLES

Define for the presence of OpenGL ES.

---

If this define exists, then OpenGL ES is supported.

See also

BURGER_OPENGL, or BURGER_VULKAN

BURGER_OVERRIDE

#define BURGER_OVERRIDE   override

Defined to nothing if the feature is not available.

---

On compilers that support override, this macro is set to override. To support this feature on older compilers, this macro is set to nothing.

See also

BURGER_CPP11, nullptr, BURGER_FINAL or BURGER_CONSTEXPR

BURGER_PAUSEOPCODE

#define BURGER_PAUSEOPCODE

(

)

Value:

(void)0

Insert a yield instruction.

---

On modern CPUs, a yield instruction exists that will cause the current thread to pause until an interrupt occurs. This is a quick way to get a thread to sleep and instantly restart to test for a mutex or other thread blocker.

Depending on compiler, this is a define or a function call.

On older CPUs, or systems that do not have threading, this does no operation. An example are 680x0 systems

BURGER_PI

#define BURGER_PI   (3.14159265358979323846264338328)

Pi as a double.

BURGER_POSTALIGN

#define BURGER_POSTALIGN

(

__a

)

Second half of a macro to force data alignment.

---

Some data needs to be aligned differently than native alignment. However, it's sometimes impractical to use the BURGER_ALIGN macro so this macro and its compliment are used to align complex objects like classes and structures. Use the code example below for proper use.

Note

The size must be a power of two. Acceptable sizes are 1, 2, 4, 8, 16 and 32. Larger are acceptable, as long as they are powers of two.

BURGER_PREALIGN(32) class foo {
public:
    foo();
    int m_Data;     // This class is 32 byte aligned
} BURGER_POSTALIGN(32);

See also

BURGER_NO_ALIGN, BURGER_PREALIGN and BURGER_ALIGN

BURGER_PPC

#define BURGER_PPC

Define to determine if code is being built for PowerPC processors.

---

If this define exists, then you are creating code that runs on the PowerPC line of processors. The Nintendo GameCube, Power Macintosh, Nintendo Wii, Sony Playstation 3 and Microsoft XBox 360 all will have this define present.

See also

BURGER_POWERPC, BURGER_POWERPC64, BURGER_XBOX360, BURGER_WII, BURGER_PS3, BURGER_MAC, BURGER_MACOSX, BURGER_BEOS or BURGER_GAMECUBE

BURGER_PREALIGN

#define BURGER_PREALIGN

(

__a

)

Value:

alignas(__a)

First half of a macro to force data alignment.

---

Some data needs to be aligned differently than native alignment. However, it's sometimes impractical to use the BURGER_ALIGN macro so this macro and its compliment are used to align complex objects like classes and structures. Use the code example below for proper use.

Note

The size must be a power of two. Acceptable sizes are 1, 2, 4, 8, 16 and 32. Larger are acceptable, as long as they are powers of two.

BURGER_PREALIGN(32) class foo {
public:
    foo();
    int m_Data;     // This class is 32 byte aligned
} BURGER_POSTALIGN(32);

See also

BURGER_NO_ALIGN, BURGER_ALIGN and BURGER_POSTALIGN

BURGER_PRINTF_ATTRIBUTE

#define BURGER_PRINTF_ATTRIBUTE	(		_index,
			_check )

Value:

    __attribute__((format(printf, _index, _check)))

Define to declare __attribute__((format)).

---

Some compilers offer validation for printf string syntax. If a function accepts printf style input strings, the input can be validated with this macro.

[Documentation on the compiler feature] (https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-format-function-attribute)

Parameters

_index	1 based index to the parameter that has the format string.
_check	1 based index to the first variable argument.

See also

BURGER_CLANG or BURGER_GNUC

BURGER_RIGHT_PARENTHESIS

#define BURGER_RIGHT_PARENTHESIS   )

The character )

---

If a macro contains a parenthesis, it will be treated as an enclosure for a parameter list. Use this macro inside another macro to output a right parenthesis without actually invoking parameters.

See also

BURGER_LEFT_PARENTHESIS

BURGER_ROUNDUP

#define BURGER_ROUNDUP	(		__value,
			__alignment )

Value:

    (((__value) + (__alignment) - 1) & ~((__alignment) - 1))

Define to round up an integer to the next power of 2.

---

For compile time constants, use this macro to take a sizeof() value and a power of 2 alignment value to round up the value to the desired power of 2.

If the value is already at that power of 2, it will be returned unchanged.

Note

If __alignment is not a power of 2, undefined behavior will occur.

Parameters

__value	Integer value to apply the alignment
__alignment	Integer power of 2.

struct V {
    uint8_t Foo;
} Value;
 
// Ensure the structure size is a power of 8
uintptr_t uNewSize = BURGER_ROUNDUP(sizeof(Value), 8);

BURGER_RTTI_IN_BASE_CLASS

#define BURGER_RTTI_IN_BASE_CLASS

(

)

Value:

public: \
    static const Burger::StaticRTTI g_StaticRTTI; \
    BURGER_INLINE const char* get_class_name(void) const BURGER_NOEXCEPT \
    { \
        return get_StaticRTTI()->get_class_name(); \
    } \
    virtual const Burger::StaticRTTI* get_StaticRTTI(void) const BURGER_NOEXCEPT

Macro for StaticRTTI support in a base class.

---

If a class needs to support StaticRTTI, insert this macro in the class declaration. Unlike the macro BURGER_RTTI_IN_CLASS(), this one adds the inline function get_class_name() to retrieve the name of the class easily.

Note

This macro will set the class setting to "public"

See also

Burger::StaticRTTI, BURGER_RTTI_IN_CLASS, BURGER_CREATE_STATICRTTI_BASE or BURGER_CREATE_STATICRTTI_PARENT

BURGER_RTTI_IN_CLASS

#define BURGER_RTTI_IN_CLASS

(

)

Value:

public: \
    static const Burger::StaticRTTI g_StaticRTTI; \
    const Burger::StaticRTTI* get_StaticRTTI(void) \
        const BURGER_NOEXCEPT BURGER_OVERRIDE

Macro for StaticRTTI support in a class.

---

If a class needs to support StaticRTTI, insert this macro in the class declaration.

Note

This macro will set the class setting to "public"

See also

Burger::StaticRTTI, BURGER_RTTI_IN_BASE_CLASS, BURGER_CREATE_STATICRTTI_BASE or BURGER_CREATE_STATICRTTI_PARENT

BURGER_RTTICAST

#define BURGER_RTTICAST	(		__ClassName,
			__Pointer )

Value:

    ((__Pointer) && \
                ((__Pointer)->get_StaticRTTI()->is_in_list( \
                    &__ClassName::g_StaticRTTI)) ? \
            static_cast<__ClassName*>(__Pointer) : \
            nullptr)

Cast up a base class with verification.

---

Given a derived class, check if the pointer is part of the derived class and return a properly cast pointer. If the test fails, return nullptr.

Parameters

__ClassName	Class name (No quotes)
__Pointer	Pointer to the base class to test

See also

Burger::StaticRTTI, BURGER_STATICRTTI_ISTYPE or BURGER_RTTICONSTCAST

BURGER_RTTICONSTCAST

#define BURGER_RTTICONSTCAST	(		__ClassName,
			__Pointer )

Value:

    ((__Pointer) && \
                ((__Pointer)->get_StaticRTTI()->is_in_list( \
                    &__ClassName::g_StaticRTTI)) ? \
            static_cast<const __ClassName*>(__Pointer) : \
            nullptr)

Cast up a const base class with verification.

---

Given a derived class, check if the pointer is part of the derived class and return a properly cast const pointer. If the test fails, return nullptr.

Parameters

__ClassName	Class name (No quotes)
__Pointer	Pointer to the base class to test

See also

Burger::StaticRTTI, BURGER_STATICRTTI_ISTYPE or BURGER_RTTICAST

BURGER_RVALUE_REFERENCES

#define BURGER_RVALUE_REFERENCES

Defined if move semantics are available.

---

On compilers that support move constructors, this define will exist.

See also

BURGER_CPP11, nullptr, BURGER_OVERRIDE or BURGER_CONSTEXPR

BURGER_SIZEOF_INT

#define BURGER_SIZEOF_INT   4

Size in bytes of the intrinsic int.

---

Define that has the number of bytes an int occupies. This value can be 2, 4 or 8. Default is 4

See also

BURGER_SIZEOF_LONG

BURGER_SIZEOF_LONG

#define BURGER_SIZEOF_LONG   4

Size in bytes of the intrinsic long.

---

Define that has the number of bytes a long occupies. This value can be 4 or 8. Default is 4.

See also

BURGER_SIZEOF_INT

BURGER_SPARC

#define BURGER_SPARC

Define to determine if code is being built for SPARC processors.

---

If this define exists, then you are creating code that runs on the SPARC line of processors.

\sa BURGER_SPARC32 or BURGER_SPARC64

BURGER_SQRT2

#define BURGER_SQRT2   (1.41421356237309504880168872421)

sqrt(2.0) as a double

BURGER_SSE

#define BURGER_SSE

Define to determine if code is being built for SSE instruction set extensions.

---

If this define exists, then you are creating code that runs a processor that has SSE instructions.

Click here to read the SSE through AVX2 instruction set

See also

BURGER_3DNOW, BURGER_SSE2, BURGER_AVX, BURGER_AVX2, BURGER_INTEL, BURGER_X86, or BURGER_AMD64

BURGER_SSE2

#define BURGER_SSE2

Define to determine if code is being built for SSE2 instruction set extensions.

---

If this define exists, then you are creating code that runs a processor that has SSE2 instructions.

Click here to read the SSE through AVX2 instruction set

See also

BURGER_3DNOW, BURGER_SSE, BURGER_AVX, BURGER_AVX2, BURGER_INTEL, BURGER_X86, or BURGER_AMD64

BURGER_STATIC_ASSERT

#define BURGER_STATIC_ASSERT

(

x

)

Value:

static_assert(x, #x)

Test a compile time condition and if it's false, force a compiler error.

---

Use either typedef int ThisIsABogusTypeDef ## LINE [(x) * 2 - 1] or static_assert() to determine if a conditional that can be determined at compile time should trigger an assert. This macro does not generate any runtime code.

Note

This macro will always invoke the conditional in all builds. The conditional must be one that is resolved at compile time.

If this macro is used in a template, it can only be used once if an old GNUC compiler (4.2 or earlier) is used because the compiler doesn't change the LINE number which can cause issues. If the compiler supports the static_assert keyword, this is not a problem.

Parameters

x	A boolean that evaluates to FALSE to force a compile time error

// Will succeed
BURGER_STATIC_ASSERT(sizeof(uint32_t)==sizeof(int32_t));
// Will fail
BURGER_STATIC_ASSERT(sizeof(char)==sizeof(int));
// Will fail if sizeof(eType) != sizeof(int)
enum eType {
    TEST
};
BURGER_STATIC_ASSERT(sizeof(eType)==sizeof(int));
 
// Use BURGER_ASSERT(x) instead, since this example is resolved at runtime
BURGER_STATIC_ASSERT(Burger::StringLength("EpicFail")==8);

BURGER_STATICRTTI_ISTYPE

#define BURGER_STATICRTTI_ISTYPE	(		__ClassName,
			__Pointer )

Value:

    (__Pointer)->get_StaticRTTI()->is_in_list(&__ClassName::g_StaticRTTI)

Return TRUE if the base class is also the requested class.

---

This macro will use the magic data in the class to find if its really the requested class.

Parameters

__ClassName	Class name (No quotes)
__Pointer	Pointer to the base class to test

See also

Burger::StaticRTTI, BURGER_RTTICAST or BURGER_RTTICONSTCAST

BURGER_STDCPP_NAME

#define BURGER_STDCPP_NAME   "C++23"

String of the C++ feature level.

---

This define is of a string naming the compiler feature level.

See also

BURGER_CPP89, BURGER_CPP98, BURGER_CPP11, BURGER_CPP14, BURGER_CPP17, or BURGER_CPP20

BURGER_STRINGIZE

#define BURGER_STRINGIZE

(

x

)

Value:

BURGER_STRINGIZE2(x)

Convert a macro into a string literal.

---

Using deep magic in the form of BURGER_STRINGIZE2, convert the macro into an 8 bit quoted string literal.

Parameters

x	Name of the macro to turn into a string

#define foo 4
printf(BURGER_STRINGIZE(foo));
 
// Prints "4" (Without the quotes)

See also

BURGER_STRINGIZE2

BURGER_STRINGIZE2

#define BURGER_STRINGIZE2

(

x

)

Value:

#x

Convert the parameter into a string literal.

---

Using the # token, convert the macro parameter into an 8 bit quoted string literal.

Parameters

x	Name of the item to turn into a string

int foo = 4;
printf(BURGER_STRINGIZE2(foo));
 
// Prints "foo" (Without the quotes)

See also

BURGER_STRINGIZE

BURGER_STRUCT_PACKPUSH

#define BURGER_STRUCT_PACKPUSH

BURGER_TCPIP

#define BURGER_TCPIP

Define for the presence of TCP/IP.

---

If this define exists, then the TCP/IP networking protocol is supported.

See also

BURGER_APPLETALK, BURGER_IPX, BURGER_STEAM, or BURGER_XBOXLIVE

BURGER_ULONGLONG

#define BURGER_ULONGLONG   Burger::ulonglong_t

Unsigned 64 bit integer type specific to the current compiler.

---

Define that has the compiler keyword that defines a 64 bit unsigned integer.

See also

BURGER_LONGLONG

BURGER_UNIX

#define BURGER_UNIX

Define to determine if code is being built on a unix platorm.

---

If this define exists, then the code is running on macOS X, tvOS, watchOS, iOS, Android, or Linux so the Unix/BSD APIs are available.

See also

BURGER_LINUX, BURGER_ANDROID, BURGER_IOS, or BURGER_MACOSX

BURGER_UNUSED

#define BURGER_UNUSED

(

x

)

Value:

(void)(x)

Define to disable the unused variable warning.

---

In cases where a variable is defined, but not used, such as in testing error conditions with asserts, this macro will alert the compiler that the existence of this variable was intentional.

Parameters

x	Name of the variable to allow to be unused

// Ignore errors on release builds
#if defined(NDEBUG)
#define I_FEAR_NOTHING(x)
#else
#define I_FEAR_NOTHING(x) x
#endif
 
int iError = FunctionThatCanFail();
// Disable unused variable warning
BURGER_UNUSED(iError);
 
I_FEAR_NOTHING(printf("Error code %d",iError));

BURGER_USED

#define BURGER_USED   __attribute__((used))

Mark with attribute((used))

---

Some compilers remove functions and variables that are not used by the program. To force a function or variable to be compiled and linked into the final product, mark it with this macro.

See also

BURGER_NODISCARD or BURGER_MAYBE_UNUSED

BURGER_VIRTUAL

#define BURGER_VIRTUAL	(		a,
			b,
			c )

Value:

a b c;

BURGER_VULKAN

#define BURGER_VULKAN

Define for the presence of Vulkan.

---

If this define exists, then Vulkan is supported.

See also

BURGER_OPENGL, or BURGER_OPENGLES

BURGER_WINDOWS

#define BURGER_WINDOWS

Define to determine if code is being built for Microsoft 32 or 64 bit Windows.

---

If this define exists, then you are creating code that runs on Microsoft Windows for either 32 or 64 bit CPUs.

Note

You may need to check the processor define, since future versions of Windows may be running on non-Pentium type processors.

See also

BURGER_WIN32, BURGER_WIN64, BURGER_MSDOS and BURGER_X86

BURGER_XBOXLIVE

#define BURGER_XBOXLIVE

Define for the presence of Microsoft's Xbox Live platform.

---

If this define exists, then the Xbox Live platform is supported. TCP/IP can be assumed to be available with this define present.

See also

BURGER_TCPIP, BURGER_APPLETALK, BURGER_IPX, or BURGER_STEAM

FALSE

#define FALSE   0

Define of the number 0 for boolean operations.

---

Note

Since this a common #define, it will first check if it's already present before defining.

See also

TRUE or NULL

MAKE_BURGER_STRING_FORMATTED_CONSTRUCTOR

#define MAKE_BURGER_STRING_FORMATTED_CONSTRUCTOR

(

N

)

Value:

    String(const char* pFmt, BURGER_SP_ARG##N) BURGER_NOEXCEPT \
        : m_pData(m_Raw), \
          m_uLength(0), \
          m_uBufferSize(kBufferSize - 1) \
    { \
        m_Raw[0] = 0; \
        const Burger::ArgumentType* args[N] = {BURGER_SP_INITARG##N}; \
        InitFormattedString(pFmt, N, args); \
    }

MAKE_BURGER_STRING_PRINTF

#define MAKE_BURGER_STRING_PRINTF

(

N

)

Value:

    void BURGER_INLINE Printf(const char* pFmt, BURGER_SP_ARG##N) \
        BURGER_NOEXCEPT \
    { \
        const Burger::ArgumentType* args[N] = {BURGER_SP_INITARG##N}; \
        InitFormattedString(pFmt, N, args); \
    }

MAKE_BURGER_STRING_PRINTF_STRREF

#define MAKE_BURGER_STRING_PRINTF_STRREF

(

N

)

Value:

    void BURGER_INLINE Printf(const String& sFmt, BURGER_SP_ARG##N) \
        BURGER_NOEXCEPT \
    { \
        const Burger::ArgumentType* args[N] = {BURGER_SP_INITARG##N}; \
        InitFormattedString(sFmt.c_str(), N, args); \
    }

NULL

#define NULL   0

Define of the number 0 for pointer invalidation.

---

Note

Since this a common #define, it will first check if it's already present before defining.

See also

FALSE or TRUE

TRUE

#define TRUE   1

Define of the number 1 for boolean operations.

---

Note

Since this a common #define, it will first check if it's already present before defining.

See also

FALSE or NULL

Typedef Documentation

Bool

typedef uint8_t Bool

Unsigned 8 bit integer for boolean operations.

---

When data storage is at a premium, this data type can be used to alert programmers that only a true or not true can be stored inside. Using the Word8 data type could imply that the data has a wider range.

See also

Word8 or Int8.

Fixed32

typedef int32_t Fixed32

Signed 32 bit integer for fixed point operations.

---

All 16.16 fixed point integer math uses this data type to alert the programmer of the special nature of the 32 bits. The upper 16 bits is an integer of the range of -32768 through 32767 and the lower 16 bits is a fraction of x/65536.

See also

BURGER_FLOAT_TO_FIXED, BURGER_FIXED_TO_FLOAT, Int32 or Frac32.

Frac32

typedef int32_t Frac32

Signed 32 bit integer for fixed point operations.

---

All 2.30 fixed point integer math uses this data type to alert the programmer of the special nature of the 32 bits. The upper 2 bits is an integer of the range of -2 through 1 and the lower 30 bits is a fraction of x/1,073,741,824.

See also

Int32 or Fixed32.

GUID

typedef struct _GUID GUID

Globally unique identifier structure.

---

128 bit value that's generated in a specific way to give a reasonable assurance that the value is unique in the whole world. While it's not 100% perfect, it's the value system used by many subsystems for Windows.

Examples of GUIDs

2F1E4FC0-81FD-11DA-9156-00036A0F876A

GUID IID_IDirect3DTexture =
    {0x2CDCD9E0,0x25A0,0x11CF,{0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 } };
GUID IID_IDirect3D =
    {0x3BBA0080,0x2421,0x11CF,{0xA3,0x1A,0x00,0xAA,0x00,0xB9,0x33,0x56 } };

Further reading http://en.wikipedia.org/wiki/Globally_unique_identifier

Note

The first three entries are stored in little endian!!

See also

_GUID

Int

typedef signed int Int

Signed integer.

---

This is the second most common data type in BurgerLib. On most platforms, this is an signed 32 bit integer but it can be 64 bit if the processor handles 64 bit data more efficiently than 32 bit. To date, all CPUs handle 32 bit data with no penalty so it's locked at 32 bits.

See also

Word

Int16

typedef int16_t Int16

16 bit signed integer.

---

This integer can contain the number -32768 through 32767. It is compiler switch setting safe.

See also

Word16

int2int_t

typedef int32_t int2int_t

int to int??_t.

---

Data type to convert native int to the int32_t, int16_t or other compatible type that reflects the proper size.

See also

uint2uint_t

Int32

typedef int32_t Int32

32 bit signed integer.

---

This integer can contain the number -2,147,483,648 through 2,147,483,647. It is compiler switch setting safe.

Note

This is cast as a signed int on the Playstation 2.

See also

Word32 or Word

Int64

typedef int64_t Int64

64 bit signed integer.

---

This integer can contain the number -9,223,372,036,854,775,808 through 9,223,372,036,854,775,807. It is compiler switch setting safe.

Note

This is cast as a signed long on the Playstation 2.

Some processors like the 680x0 do not have registers this large and as a result it will incur a performance penalty. Use this type carefully.

See also

Word64

Int8

typedef int8_t Int8

8 bit signed integer.

---

This integer can contain the number -128 through 127. It is compiler switch setting safe.

See also

Word8

int_t

typedef signed int int_t

Signed integer.

---

This is the second most common data type in BurgerLib. On most platforms, this is an signed 32 bit integer but it can be 64 bit if the processor handles 64 bit data more efficiently than 32 bit. To date, all CPUs handle 32 bit data with no penalty so it's locked at 32 bits.

See also

uint_t

IntPtr

typedef intptr_t IntPtr

Signed integer that matches in size to a void *.

---

Since address pointers can be 64 bit on some platforms, this type allows the casting and storing of this type into an signed integer.

Note

Caution should be used when using this type in data structures due to it being 64 or 32 bit on different platforms.

See also

WordPtr

long2int_t

typedef int32_t long2int_t

long to int??_t.

---

Data type to convert native long to the int32_t, int64_t or other compatible type that reflects the proper size.

See also

ulong2uint_t

uint2uint_t

typedef uint32_t uint2uint_t

unsigned int to uint??_t.

---

Data type to convert native unsigned int to the uint32_t, uint16_t or other compatible type that reflects the proper size.

See also

int2int_t

uint_t

typedef unsigned int uint_t

Unsigned integer.

Was GPU vertex processed devices allowed?

Was hardware vertex processed devices allowed?

Test if Anti-Aliasing is enabled.

---

This is the most common data type in BurgerLib. On most platforms, this is an unsigned 32 bit integer but it can be 64 bit if the processor handles 64 bit data more efficiently than 32 bit. To date, all CPUs handle 32 bit data with no penalty so it's locked at 32 bits.

See also

int_t

---

Burger::DisplayDirectX9::DeviceSettings_t::IsMSAASwapChainCreated(void) const

Returns

TRUE if Anti-aliasing is turned on

See also

IsVSyncEnabled(void) const

---

Burger::DisplayDirectX9::Enumerator::GetSoftwareVertexProcessingFlag( void) const

\brief Was software vertex processed devices allowed?

\return \ref TRUE if software vertex rendering devices are allowed.

\sa Enumerate(IDirect3D9 *,IsDeviceOkayProc,void *),

GetHardwareVertexProcessingFlag(void) const, GetPureHarewareVertexProcessingFlag(void) const, or GetMixedVertexProcessingFlag(void) const

---

Burger::DisplayDirectX9::Enumerator::GetHardwareVertexProcessingFlag(void) const

Returns

TRUE if hardware vertex rendering devices are allowed.

See also

Enumerate(IDirect3D9 *,IsDeviceOkayProc,void *), GetSoftwareVertexProcessingFlag(void) const, GetPureHarewareVertexProcessingFlag(void) const, or GetMixedVertexProcessingFlag(void) const

---

Burger::DisplayDirectX9::Enumerator::GetPureHarewareVertexProcessingFlag(void) const

\return \ref TRUE if GPU vertex rendering devices are allowed.

\sa Enumerate(IDirect3D9 *,IsDeviceOkayProc,void *),

GetSoftwareVertexProcessingFlag(void) const, GetHardwareVertexProcessingFlag(void) const, or GetMixedVertexProcessingFlag(void) const

ulong2uint_t

typedef uint32_t ulong2uint_t

unsigned long to uint??_t.

---

Data type to convert native unsigned long to the uint32_t, uint64_t or other compatible type that reflects the proper size.

See also

long2int_t

Vector_128

typedef __m128 Vector_128

Word

typedef unsigned int Word

Unsigned integer.

---

This is the most common data type in BurgerLib. On most platforms, this is an unsigned 32 bit integer but it can be 64 bit if the processor handles 64 bit data more efficiently than 32 bit. To date, all CPUs handle 32 bit data with no penalty so it's locked at 32 bits.

See also

Int

Word16

typedef uint16_t Word16

16bit unsigned integer.

---

This integer can contain the number 0 through 65535. It is compiler switch setting safe.

See also

Int16

Word32

typedef uint32_t Word32

32 bit unsigned integer.

---

This integer can contain the number 0 through 4,294,967,295. It is compiler switch setting safe.

Note

This is cast as an unsigned int on the Playstation 2.

See also

Int32 or Int

Word64

typedef uint64_t Word64

64 bit unsigned integer.

---

This integer can contain the number 0 through 18,446,744,073,709,551,615. It is compiler switch setting safe.

Note

This is cast as an unsigned long on the Playstation 2.

Some processors like the 680x0 do not have registers this large and as a result it will incur a performance penalty. Use this type carefully.

See also

Int64

Word8

typedef uint8_t Word8

8 bit unsigned integer.

---

This integer can contain the number 0 through 255. It is compiler switch setting safe.

See also

Int8

WordPtr

typedef uintptr_t WordPtr

Unsigned integer that matches in size to a void *.

---

Since address pointers can be 64 bit on some platforms, this type allows the casting and storing of this type into an unsigned integer.

Note

Caution should be used when using this type in data structures due to it being 64 or 32 bit on different platforms.

See also

IntPtr

Function Documentation

_BurgerArraySize()

template<typename T , uintptr_t N>

const char(* _BurgerArraySize ( T(&) [N] ) )[N]

extern

Helper for BURGER_ARRAYSIZE.

---

Non-existent array for determining array element size.

Template Parameters

T	Data type of the elements of the array/
N	Number of elements in the array

See also

BURGER_ARRAYSIZE

_swapendian16()

uint16_t _swapendian16 ( uint16_t uInput )

externnoexcept

Swap endian of a 16 bit integer.

---

Reverse the endian of a 16 bit integer. Implemented in assembly on some platforms.

Parameters

uInput

The value to return endian swapped

Returns

Input endian swapped

See also

_swapendian32(uint32_t), or _swapendian64(uint64_t)

_swapendian32()

uint32_t _swapendian32 ( uint32_t uInput )

externnoexcept

Swap endian of a 32 bit integer.

---

Reverse the endian of a 32 bit integer. Implemented in assembly on some platforms.

Parameters

uInput

The value to return endian swapped

Returns

Input endian swapped

See also

_swapendian16(uint16_t), or _swapendian64(uint64_t)

_swapendian64()

uint64_t _swapendian64 ( uint64_t uInput )

externnoexcept

Swap endian of a 64 bit integer.

---

64 bit operations for endian swap are specialized on different platforms since some forms require the return value to be in a structure.

Parameters

uInput

64 integer to swap endian.

Returns

Input with all 8 bytes reversed.

See also

_swapendian16(uint16_t), or _swapendian32(uint32_t)

_swapendian64ptr()

uint64_t _swapendian64ptr ( const void * pInput )

externnoexcept

Load a 64 bit value endian swapped.

---

Reverse the endian of a 64 bit integer and as it is being read from memory

Note

This function only exists on XCode for PowerPC. The compiler generates bad code when using __ldwbrx on 64 bit integers.

Parameters

pInput

Pointer to 64 bit aligned memory

Returns

The value to read with endian swapped.

See also

_swapendianstore64(void *, uint64_t)

_swapendianstore16()

void _swapendianstore16 ( void * pOutput, uint16_t uInput )

externnoexcept

Store a 16 bit value endian swapped.

---

Reverse the endian of a 16 bit integer and store the value to memory

Note

This function only exists on Metrowerks for PowerPC. It's a workaround for a pointer propagation bug when using the intrinsic __sthbrx

Parameters

pOutput	Pointer to 16 bit aligned memory
uInput	The value to store endian swapped

See also

_swapendianstore32(void *, uint32_t), or _swapendianstore64(void *, uint64_t)

_swapendianstore32()

void _swapendianstore32 ( void * pOutput, uint32_t uInput )

externnoexcept

Store a 32 bit value endian swapped.

---

Reverse the endian of a 32 bit integer and store the value to memory

Note

This function only exists on Metrowerks for PowerPC. It's a workaround for a pointer propagation bug when using the intrinsic __stwbrx

Parameters

pOutput	Pointer to 32 bit aligned memory
uInput	The value to store endian swapped

See also

_swapendianstore16(void *, uint16_t), or _swapendianstore64(void *, uint64_t)

_swapendianstore64()

void _swapendianstore64 ( void * pOutput, uint64_t uInput )

externnoexcept

Store a 64 bit value endian swapped.

---

Reverse the endian of a 64 bit integer and store the value to memory

Note

This function only exists on Metrowerks for PowerPC and XCode for PowerPC. Both compilers generate bad code when using __stwbrx on 64 bit integers.

Parameters

pOutput	Pointer to 64 bit aligned memory
uInput	The value to store endian swapped

See also

_swapendianstore16(void* , uint16_t), _swapendianstore32(void* , uint32_t), or _swapendian64ptr(const void* pInput)

CodeEntry()

int CodeEntry ( Burger::GameApp * pGameApp )

extern

Main entry of the application code.

---

Due to the mish mosh of startup code methods across platforms, Burgerlib uses the inclusion of the header <brstartup.h> to create the proper code to initialize an application and then it will call this function to start application execution. This is the prototype of the function that must exist in a Burgerlib application. This function is not supplied by Burgerlib.

#include <burger.h>
 
// Only include once in the whole project
#include <brstartup.h>
 
int BURGER_API CodeEntry(Burger::GameApp *pGameApp)
{
    // Initialize the keyboard
    Burger::Keyboard KeyInstance(pGameApp);
    // Initialize the mouse
    Burger::Mouse MouseInstance(pGameApp);
 
    // Run the game
    DoAGreatGame(pGameApp);
    return 0;       // No errors
}

Returns

Zero if the application executed without error, non-zero if not.

See also

Burger::GameApp, Burger::Keyboard or Burger::Mouse

exchange()

template<class T >

void exchange ( T & __A, T & __B )

inline

maximum()

template<typename T >

T maximum ( T A, T B )

inlineconstexprnoexcept

minimum()

template<typename T >

T minimum ( T A, T B )

inlineconstexprnoexcept

operator new()

void * operator new ( unsigned long , void * x )

inlinenoexcept

round_up_pointer()

template<typename T >

T * round_up_pointer ( T * pInput, uintptr_t uSize = alignment_of<T>::value )

noexcept

swap_variables()

template<class T >

void swap_variables ( T * pA, T * pB )

inline