From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a05378.html | 15497 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 15497 insertions(+) create mode 100644 docs/doxygen/nel/a05378.html (limited to 'docs/doxygen/nel/a05378.html') diff --git a/docs/doxygen/nel/a05378.html b/docs/doxygen/nel/a05378.html new file mode 100644 index 00000000..a2b79a4a --- /dev/null +++ b/docs/doxygen/nel/a05378.html @@ -0,0 +1,15497 @@ + + +NeL: NLMISC Namespace Reference + + + +

NLMISC Namespace Reference

Detailed Description

+This namespace contains all miscellaneous class used by other module. +

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Data Structures
class CAABBox
class CAABBoxExt
struct CAngleAxis
class CAsyncFileManager
class CAsyncFileManager::CFileLoad
class CAsyncFileManager::CMultipleFileLoad
class CAsyncFileManager::CSignal
class CAsyncFileManager::ICancelCallback
class CAutoTimer
class CAutoTimerInst
class CBGRA
class CBigFile
struct CBigFile::BNP
struct CBigFile::BNPFile
class CBigFile::CBNPFileComp
struct CBigFile::CHandleFile
class CBigFile::CThreadFileArray
class CBitmap
class CBitMemStream
class CBitSet
class CBlockMemory
struct CBlockMemory::CBlock
a block. More...

class CBMSDbgInfo
class CBSphere
class CBSPNode2v
class CBufFIFO
class CCategoryMap
class CClassId
class CClassRegistry
struct CClassRegistry::CClassNode
class CConcavePolygonsVertexDesc
class CConfigFile
struct CConfigFile::CVar
class CContiguousBlockAllocator
struct CCpuInfo___
class CDbgPtr
class CDbgRefCount
class CEidHash
struct CEntityId
class CEntityIdTranslator
struct CEntityIdTranslator::CEntity
class CEvalNumExpr
class CEvent
class CEventActivate
class CEventChar
class CEventDestroyWindow
class CEventEmitterMulti
class CEventKey
class CEventKeyDown
class CEventKeyUp
class CEventListenerAsync
class CEventMouse
class CEventMouseDblClk
class CEventMouseDown
class CEventMouseMove
class CEventMouseUp
class CEventMouseWheel
class CEventServer
class CEventSetFocus
class CFairMutex
class CFairSynchronized
class CFairSynchronized::CAccessor
class CFastMem
class CFastMutex
class CFastMutexMP
struct CFile
class CFileDisplayer
struct CFileEntry
class CFixedSizeAllocator
class CFixedSizeAllocator::CChunk
class CFixedSizeAllocator::CNode
struct CGameDeviceDesc
Describe a game device. More...

class CGameDeviceEvent
class CGDAxisMoved
An axis has moved. More...

class CGDButton
class CGDButtonDown
class CGDButtonUp
class CGDMouseMove
A raw mouse move message, expressed in mickeys (relative values). More...

class CGDPOVChanged
A point of view control changed. More...

class CGDSliderMoved
A slider position has changed. More...

class CHashBySheetId
struct CHashFunctionUInt64
class CHeapAllocator
struct CHeapAllocator::CCategory
struct CHeapAllocator::CFreeNode
struct CHeapAllocator::CMainBlock
struct CHeapAllocator::CMemoryLeakBlock
struct CHeapAllocator::CNodeBegin
struct CHeapAllocator::CNodeEnd
struct CHeapAllocator::CNullNode
struct CHeapAllocator::CSmallBlockPool
class CHeapMemory
struct CHeapMemory::CEmptySpace
class CHTimer
struct CHTimer::CExamStackEntry
struct CHTimer::CNode
a node in an execution path More...

struct CHTimer::CNodeStat
struct CHTimer::CStats
struct CHTimer::CStatSorter
struct CHTimer::CTimerStat
class CI18N
struct CI18N::ILoadProxy
class CIFile
struct CInputDeviceEventLess
class CInputDeviceServer
struct CLeak
class CLightMemDisplayer
class CLine
class CLineColor
class CLineColorUV
class CLineUV
class CLog
struct CLog::TDisplayInfo
class CMatrix
class CMemDisplayer
class CMemStream
class CMouseSmoother
class CMouseSmoother::CSample
class CMsgBoxDisplayer
class CNoiseColorGradient
class CNoiseValue
class CObjectArenaAllocator
class CObjectVector
class CObjectVector< double, true >
class CObjectVector< float, true >
class CObjectVector< sint16, true >
class CObjectVector< sint32, true >
class CObjectVector< sint64, true >
class CObjectVector< sint8, true >
class CObjectVector< uint16, true >
class CObjectVector< uint32, true >
class CObjectVector< uint64, true >
class CObjectVector< uint8, true >
class COFile
class COXml
class CPath
struct CPath::CFileEntry
class CPath::CMCFileComp
struct CPath::CMCFileEntry
class CPlane
class CPolygon
class CPolygon2D
class CPoolMemory
class CQuad
class CQuadColor
class CQuadColorUV
class CQuadColorUV2
class CQuadUV
class CQuat
class CQuatD
class CQuatT
class CRandom
class CRandomGrid3D
A static 3D array of random value + other infos for noise. More...

class CReaderWriter
class CRect
class CRefCount
struct CRefCount::CPtrInfo
class CRefPtr
class CRGBA
class CRGBAF
class CRWSynchronized
class CRWSynchronized::CReadAccessor
class CRWSynchronized::CWriteAccessor
struct CSerialCommand
class CSharedMemory
class CSharedMutex
class CSheetId
class CSheetId::CChar
associate sheet id and sheet name More...

class CSheetId::CCharComp
union CSheetId::TSheetId
sheet id More...

class CSimpleClock
class CSingleton
class CSmartPtr
class CSString
class CStaticMap
class CStaticMap::value_compare
class CStaticStringMapper
class CstCDbgPtr
class CStdDisplayer
class CSTLBlockAllocator
class CSTLBlockList
class CStopWatch
class CStringConversion
struct CStringConversion::CPair
class CStringIdArray
class CStringMapper
class CStringMapper::CCharComp
class CStringStream
class CSystemInfo
class CTaskManager
class CTaskManager::CWaitingTask
class CTaskManager::IChangeTaskPriority
A callback to modify the task priority. More...

class CTDS
class CTime
struct CTraits
struct CTraits< bool >
struct CTraits< char >
struct CTraits< CRGBA >
struct CTraits< CVector >
struct CTraits< double >
struct CTraits< float >
struct CTraits< sint >
struct CTraits< sint16 >
struct CTraits< sint32 >
struct CTraits< sint64 >
struct CTraits< sint8 >
struct CTraits< uint >
struct CTraits< uint16 >
struct CTraits< uint32 >
struct CTraits< uint64 >
struct CTraits< uint8 >
struct CTraits< unsigned char >
class CTriangle
class CTriangleColor
class CTriangleColorUV
class CTriangleUV
class CUnfairMutex
class CUnfairSynchronized
class CUnfairSynchronized::CAccessor
struct CUnsensitiveStrLessPred
class CUpdateThread
class CUV
class CUVW
class CValueSmoother
class CValueSmootherTemplate
class CValueSmootherTemplate< bool >
class CVariable
class CVariable< std::string >
class CVariablePtr
class CVector
class CVector2d
class CVector2f
class CVectorD
class CVectorH
class CVectorSString
class CWindowDisplayer
struct CWindowDisplayer::CLabelEntry
class CWordsDictionary
struct EAllocationFailure
struct EBadSize
struct EBadType
struct EConfigFile
struct EDDSBadHeader
struct EFatalError
struct EFile
struct EFileNotFound
struct EFileNotOpened
struct EInputDevice
struct EInvalidDataStream
struct EMemStream
Exception class for CMemStream. More...

struct EmitterEqualPred
struct ENewerStream
struct EOlderStream
struct EParseError
struct EPathNotFound
Exception throwed when a find is not found in a lookup() call. More...

struct EReadError
struct EReallocationFailed
struct ERegisteredClass
struct ERegistry
struct ERenameError
struct ESeekFailed
struct ESeekNotSupported
struct EStream
struct EStreamOverflow
This exception is raised when someone tries to serialize in more than there is. More...

struct EThread
class ETrapDebug
struct EUnknownVar
struct EUnregisteredClass
struct EWriteError
class Exception
struct EXmlParsingError
class IClassable
class ICommand
class IDisplayer
class IEventEmitter
class IEventListener
struct IGameDevice
struct IInputDevice
struct IInputDeviceEvent
struct IInputDeviceManager
struct IKeyboardDevice
struct IMouseDevice
An interface to a low level mouse device. More...

class IProcess
class IProgressCallback
class IProgressCallback::CCropedValues
class IRunnable
class IRunnablePos
class IStream
class IStreamable
class IThread
class IVariable
struct TBMSDbgInfoData
struct TBMSSerialInfo

Configuration
typedef CFastMutex CAllocatorMutex

Quaternions functions.
template<class T> CQuatT< T > operator * (T f, const CQuatT< T > &o)
f*quat operator

Typedefs
typedef std::multimap< CClassId,
+ IEventListener * > mapListener
typedef void *(* memcpyPtr )(void *dts, const void *src, size_t nbytes)
typedef std::vector< TBMSSerialInfo > TBMSSerialInfoList
typedef std::map< float, CConcavePolygonsVertexDesc > TCConcavePolygonsVertexMap
typedef sint64 TCPUCycle
typedef std::string(* TCrashCallback )()
typedef std::vector< CGameDeviceDesc > TDeviceDescVect
typedef bool(* TEmailFunction )(const std::string &smtpServer, const std::string &from, const std::string &to, const std::string &subject, const std::string &body, const std::string &attachedFile="", bool onlyCheck=false)
typedef uint32 TGameCycle
typedef double TGameTime
New time types.

typedef std::map< std::string,
+ CLeak > TLinkMap
typedef double TLocalTime
typedef uint32 TMsDuration
typedef key_t TSharedMemId
typedef uint TSStringId
typedef uint TStringId
typedef uint32 TTickDuration
typedef sint64 TTicks
typedef sint64 TTime
Old time type.

Enumerations
enum TKey {
+  Key0 = '0', +Key1 = '1', +Key2 = '2', +Key3 = '3', +
+  Key4 = '4', +Key5 = '5', +Key6 = '6', +Key7 = '7', +
+  Key8 = '8', +Key9 = '9', +KeyA = 'A', +KeyB = 'B', +
+  KeyC = 'C', +KeyD = 'D', +KeyE = 'E', +KeyF = 'F', +
+  KeyG = 'G', +KeyH = 'H', +KeyI = 'I', +KeyJ = 'J', +
+  KeyK = 'K', +KeyL = 'L', +KeyM = 'M', +KeyN = 'N', +
+  KeyO = 'O', +KeyP = 'P', +KeyQ = 'Q', +KeyR = 'R', +
+  KeyS = 'S', +KeyT = 'T', +KeyU = 'U', +KeyV = 'V', +
+  KeyW = 'W', +KeyX = 'X', +KeyY = 'Y', +KeyZ = 'Z', +
+  KeyLBUTTON = 0x01, +KeyRBUTTON = 0x02, +KeyCANCEL = 0x03, +KeyMBUTTON = 0x04, +
+  KeyBACK = 0x08, +KeyTAB = 0x09, +KeyCLEAR = 0x0C, +KeyRETURN = 0x0D, +
+  KeySHIFT = 0x10, +KeyCONTROL = 0x11, +KeyMENU = 0x12, +KeyPAUSE = 0x13, +
+  KeyCAPITAL = 0x14, +KeyKANA = 0x15, +KeyHANGEUL = 0x15, +KeyHANGUL = 0x15, +
+  KeyJUNJA = 0x17, +KeyFINAL = 0x18, +KeyHANJA = 0x19, +KeyKANJI = 0x19, +
+  KeyESCAPE = 0x1B, +KeyCONVERT = 0x1C, +KeyNONCONVERT = 0x1D, +KeyACCEPT = 0x1E, +
+  KeyMODECHANGE = 0x1F, +KeySPACE = 0x20, +KeyPRIOR = 0x21, +KeyNEXT = 0x22, +
+  KeyEND = 0x23, +KeyHOME = 0x24, +KeyLEFT = 0x25, +KeyUP = 0x26, +
+  KeyRIGHT = 0x27, +KeyDOWN = 0x28, +KeySELECT = 0x29, +KeyPRINT = 0x2A, +
+  KeyEXECUTE = 0x2B, +KeySNAPSHOT = 0x2C, +KeyINSERT = 0x2D, +KeyDELETE = 0x2E, +
+  KeyHELP = 0x2F, +KeyLWIN = 0x5B, +KeyRWIN = 0x5C, +KeyAPPS = 0x5D, +
+  KeyNUMPAD0 = 0x60, +KeyNUMPAD1 = 0x61, +KeyNUMPAD2 = 0x62, +KeyNUMPAD3 = 0x63, +
+  KeyNUMPAD4 = 0x64, +KeyNUMPAD5 = 0x65, +KeyNUMPAD6 = 0x66, +KeyNUMPAD7 = 0x67, +
+  KeyNUMPAD8 = 0x68, +KeyNUMPAD9 = 0x69, +KeyMULTIPLY = 0x6A, +KeyADD = 0x6B, +
+  KeySEPARATOR = 0x6C, +KeySUBTRACT = 0x6D, +KeyDECIMAL = 0x6E, +KeyDIVIDE = 0x6F, +
+  KeyF1 = 0x70, +KeyF2 = 0x71, +KeyF3 = 0x72, +KeyF4 = 0x73, +
+  KeyF5 = 0x74, +KeyF6 = 0x75, +KeyF7 = 0x76, +KeyF8 = 0x77, +
+  KeyF9 = 0x78, +KeyF10 = 0x79, +KeyF11 = 0x7A, +KeyF12 = 0x7B, +
+  KeyF13 = 0x7C, +KeyF14 = 0x7D, +KeyF15 = 0x7E, +KeyF16 = 0x7F, +
+  KeyF17 = 0x80, +KeyF18 = 0x81, +KeyF19 = 0x82, +KeyF20 = 0x83, +
+  KeyF21 = 0x84, +KeyF22 = 0x85, +KeyF23 = 0x86, +KeyF24 = 0x87, +
+  KeyNUMLOCK = 0x90, +KeySCROLL = 0x91, +KeyLSHIFT = 0xA0, +KeyRSHIFT = 0xA1, +
+  KeyLCONTROL = 0xA2, +KeyRCONTROL = 0xA3, +KeyLMENU = 0xA4, +KeyRMENU = 0xA5, +
+  KeySEMICOLON = 0xBA, +KeyEQUALS = 0xBB, +KeyCOMMA = 0xBC, +KeyDASH = 0xBD, +
+  KeyPERIOD = 0xBE, +KeySLASH = 0xBF, +KeyTILDE = 0xC0, +KeyLBRACKET = 0xDB, +
+  KeyBACKSLASH = 0xDC, +KeyRBRACKET = 0xDD, +KeyAPOSTROPHE = 0xDE, +KeyPROCESSKEY = 0xE5, +
+  KeyATTN = 0xF6, +KeyCRSEL = 0xF7, +KeyEXSEL = 0xF8, +KeyEREOF = 0xF9, +
+  KeyPLAY = 0xFA, +KeyZOOM = 0xFB, +KeyNONAME = 0xFC, +KeyPA1 = 0xFD, +
+  KeyOEM_CLEAR = 0xFE, +KeyCount = 0xFF +
+ }
enum TKeyButton { noKeyButton = 0x0, +ctrlKeyButton = 0x8, +shiftKeyButton = 0x10, +altKeyButton = 0x20 + }
enum TMouseButton {
+  noButton = 0x0, +leftButton = 0x1, +middleButton = 0x2, +rightButton = 0x4, +
+  ctrlButton = 0x8, +shiftButton = 0x10, +altButton = 0x20 +
+ }
enum TReportResult { ReportDebug, +ReportIgnore, +ReportQuit, +ReportError + }

Functions
string addSlashR (string str)
int atoihex (const char *ident)
sint64 atoiInt64 (const char *ident, sint64 base)
Convert a string into an sint64 (same as atoi() function but for 64 bits intergers).

uint32 atoui (const char *ident)
void beep (uint freq, uint duration)
uint32 blend (uint32 &n0, uint32 &n1, uint32 coef0)
void blendFromui (NLMISC::CRGBA &c0, NLMISC::CRGBA &c1, uint coef)
void BuildHermiteVector (const NLMISC::CVector2f &P0, const NLMISC::CVector2f &P1, const NLMISC::CVector2f &T0, const NLMISC::CVector2f &T1, NLMISC::CVector2f &dest, float lambda)
build some hermite spline value, with the given points and tangents

string bytesToHumanReadable (uint32 bytes)
string bytesToHumanReadable (const std::string &bytes)
Convert a number in bytes into a string that is easily readable by an human, for example 105123 -> "102kb".

void cbInvalidEntityNamesFilename (const std::string &invalidEntityNamesFilename)
void cbVarChanged (CConfigFile::CVar &cvar)
void changeLogDirectory (const std::string &dir)
void CHeapAllocatorOutputError (const char *str)
template<class T, class U, class V> void clamp (T &v, const U &min, const V &max)
template<class T, class U> T computeBilinear (const T &v0, const T &v1, const T &v2, const T &v3, const U &s, const U &t)
template<class T> void contReset (T &a)
bool CopyMoveFile (const char *dest, const char *src, bool copyFile, bool failIfExists=false)
void createDebug (const char *logPath, bool logInFile)
float degToRad (float deg)
bool DetectMMX (void)
bool DetectSSE (void)
void displayBitStream (const CBitMemStream &msg, sint beginbitpos, sint endbitpos, NLMISC::CLog *log)
Display a part of a bitmemstream.

void displayByteBits (uint8 b, uint nbits, sint beginpos, bool displayBegin, NLMISC::CLog *log)
Display the bits (with 0 and 1) composing a byte (from right to left).

void displayCallStack (CLog *log)
void displayDwordBits (uint32 b, uint nbits, sint beginpos, bool displayBegin, NLMISC::CLog *log)
Display the bits (with 0 and 1) composing a number (uint32) (from right to left).

void drawFullLine (float x0, float y0, float x1, float y1, std::vector< std::pair< sint, sint > > &result)
void drawLine (float x0, float y0, float x1, float y1, std::vector< std::pair< sint, sint > > &result)
void drawLine (float x0, float y0, float x1, float y1, vector< pair< sint, sint > > &result)
void enterBreakpoint (const char *message)
void explode (const std::string &src, const std::string &sep, std::vector< std::string > &res, bool skipEmpty)
void fastClamp8 (sint &v)
memcpyPtr findBestmemcpy ()
void fprintf_int (uint value)
float frand (float mod)
uint32 fromHumanReadable (const std::string &str)
Get a bytes or time in string format and convert it in seconds or bytes.

void fromString (const std::string &str, std::string &val)
void fromString (const std::string &str, bool &val)
void fromString (const std::string &str, double &val)
void fromString (const std::string &str, float &val)
void fromString (const std::string &str, sint64 &val)
void fromString (const std::string &str, uint64 &val)
void fromString (const std::string &str, sint16 &val)
void fromString (const std::string &str, uint16 &val)
void fromString (const std::string &str, sint8 &val)
void fromString (const std::string &str, uint8 &val)
void fromString (const std::string &str, sint32 &val)
void fromString (const std::string &str, uint32 &val)
sint fsgn (double f)
void getCallStackAndLog (string &result, sint skipNFirst)
Get the call stack and set it with result.

string getname (dirent *de)
uint getPowerOf2 (uint v)
uint getThreadId ()
Returns Process Id (note: on Linux, Process Id is the same as the Thread Id) Returns Thread Id (note: on Linux, Process Id is the same as the Thread Id).

float HLSValue (float h, float v1, float v2)
Used by buildFromHLS.

uint32 humanReadableToBytes (const std::string &str)
Convert a human readable into a bytes, for example "102kb" -> 105123.

uint32 humanReadableToBytes (const string &str)
void initDebug2 (bool logInFile)
bool isdirectory (dirent *de)
bool isfile (dirent *de)
bool isPowerOf2 (sint32 v)
double isValidDouble (double v)
void itoaInt64 (sint64 number, char *str, sint64 base)
Convert an sint64 into a string (same as itoa() function but for 64 bits intergers).

CStringConversion< TKey > KeyConversion (stringTable, sizeof(stringTable)/sizeof(stringTable[0]), KeyCount)
bool killProgram (uint32 pid)
This function kill a program using his pid (on unix, it uses the kill() POSIX function).

bool launchProgram (const std::string &programName, const std::string &arguments)
template<class T> T maxof (const T &a, const T &b, const T &c, const T &d, const T &e)
template<class T> T maxof (const T &a, const T &b, const T &c, const T &d)
template<class T> T maxof (const T &a, const T &b, const T &c)
template<class T> T minof (const T &a, const T &b, const T &c, const T &d, const T &e)
template<class T> T minof (const T &a, const T &b, const T &c, const T &d)
template<class T> T minof (const T &a, const T &b, const T &c)
CPolygon2D::TVec2fVect::const_iterator Next (const CPolygon2D::TVec2fVect::const_iterator &it, const CPolygon2D::TVec2fVect &cont)
NL_TRIVIAL_TYPE_TRAITS (NL3D::CPlaneBasis)
void nlError (const char *format,...)
Never use this function but call the nlerror macro (internal use only).

void nlFatalError (const char *format,...)
Never use this function (internal use only).

int nlfseek64 (FILE *stream, sint64 offset, int origin)
NLMISC_COMMAND (displayMeasures,"display hierarchical timer","[depth]")
NLMISC_COMMAND (playerInfo,"Get informations about a player or all players in CEntityIdTranslator","[< entityname >|< eid >|< username >|< uid >]")
NLMISC_COMMAND (entityNameValid,"Tell if an entity name is valid or not using CEntityIdTranslator validation rulez","< entityname >")
NLMISC_COMMAND (findEIdByEntity,"Find entity id using the entity name","< entityname >|< eid >")
NLMISC_COMMAND (findEIdByUser,"Find entity ids using the user name","< username >|< uid >")
NLMISC_COMMAND (readaccess,"read a uint8 value in an invalid address","[< adr >]")
NLMISC_COMMAND (writeaccess,"write a uint8 value in an invalid address","[< adr >[< value >]]")
NLMISC_COMMAND (divbyzero,"generate a divide by zero","")
NLMISC_COMMAND (abort,"generate a abort()","")
NLMISC_COMMAND (stop,"generate a nlstop()","")
NLMISC_COMMAND (assert,"generate a failed nlassert()","")
NLMISC_COMMAND (displayFilterWarning,"display filter on WarningLog","")
NLMISC_COMMAND (removeFilterWarning,"remove a filter on WarningLog","[< filterstr >]")
NLMISC_COMMAND (addNegativeFilterWarning,"add a negative filter on WarningLog","< filterstr >")
NLMISC_COMMAND (addPositiveFilterWarning,"add a positive filter on WarningLog","< filterstr >")
NLMISC_COMMAND (displayFilterInfo,"display filter on InfoLog","[d|i|w|e]")
NLMISC_COMMAND (removeFilterInfo,"remove a filter on InfoLog","[< filterstr >]")
NLMISC_COMMAND (addNegativeFilterInfo,"add a negative filter on InfoLog","< filterstr >")
NLMISC_COMMAND (addPositiveFilterInfo,"add a positive filter on InfoLog","< filterstr >")
NLMISC_COMMAND (displayFilterDebug,"display filter on DebugLog","")
NLMISC_COMMAND (removeFilterDebug,"remove a filter on DebugLog","[< filterstr >]")
NLMISC_COMMAND (addNegativeFilterDebug,"add a negative filter on DebugLog","< filterstr >")
NLMISC_COMMAND (addPositiveFilterDebug,"add a positive filter on DebugLog","< filterstr >")
NLMISC_COMMAND (resetFilters,"disable all filters on Nel loggers","[debug|info|warning|error|assert]")
NLMISC_COMMAND (displayMemlog,"displays the last N line of the log in memory","[< NbLines >]")
NLMISC_COMMAND (killProgram,"kill a program given the pid","< pid >")
NLMISC_COMMAND (launchProgram,"Execute the command line using launcProgram() function call(launch in background task without waiting the end of the execution)","< programName >< arguments >")
NLMISC_COMMAND (system,"Execute the command line using system() function call(wait until the end of the command)","< commandline >")
NLMISC_COMMAND (sleep,"Freeze the service for N seconds(for debug purpose)","< N >")
NLMISC_COMMAND (stohr,"Convert a second number into an human readable time","< int >")
NLMISC_COMMAND (hrtob,"Convert a human readable number into a bytes number","< hr >")
NLMISC_COMMAND (btohr,"Convert a bytes number into an human readable number","< int >")
NLMISC_COMMAND (help,"display help on a specific variable/commands or on all variables and commands","[< variable >|< command >]")
NLMISC_DYNVARIABLE (string, OS,"OS used")
NLMISC_DYNVARIABLE (string, ProcessUsedMemory,"Memory used by this process in bytes")
NLMISC_DYNVARIABLE (string, TotalPhysicalMemory,"Total physical memory on this computer in bytes")
NLMISC_DYNVARIABLE (string, AvailablePhysicalMemory,"Physical memory available on this computer in bytes")
void nlSleep (uint32 ms)
sint nlstricmp (const char *lhs, const std::string &rhs)
sint nlstricmp (const std::string &lhs, const char *rhs)
sint nlstricmp (const std::string &lhs, const std::string &rhs)
sint nlstricmp (const char *lhs, const char *rhs)
CVectorD operator * (double f, const CVectorD &v)
CVector operator * (float f, const CVector &v)
CVector2f operator * (float f, const CVector2f &v)
CVector2d operator * (double f, const CVector2d &v)
CUV operator * (const CUV &uv, float f)
CUV operator * (float f, const CUV &uv)
CRGBAF operator * (float f, const CRGBAF &c)
CPlane operator * (const CPlane &p, const CMatrix &m)
bool operator!= (const CGameDeviceDesc &lhs, const CGameDeviceDesc &rhs)
bool operator< (const CVector2f &lhs, const CVector2f &rhs)
bool operator< (const CPolygon2D &lhs, const CPolygon2D &rhs)
bool operator== (const CGameDeviceDesc &lhs, const CGameDeviceDesc &rhs)
for devices comparison. The 'Connected' field is ignored.

bool operator== (const CPolygon2D &lhs, const CPolygon2D &rhs)
sint OptFastFloor (float x)
uint32 OptFastFloor24 (float x)
void OptFastFloorBegin ()
void OptFastFloorBegin24 ()
void OptFastFloorEnd ()
void OptFastFloorEnd24 ()
float OptFastFractionnalPart (float x)
CPolygon2D::TVec2fVect::const_iterator Prev (const CPolygon2D::TVec2fVect::const_iterator &it, const CPolygon2D::TVec2fVect &cont)
float radToDeg (float rad)
uint raiseToNextPowerOf2 (uint v)
void removeAllUnusedChar (string &str)
string removeSlashR (string str)
TReportResult report (const std::string &title, const std::string &header, const std::string &subject, const std::string &body, bool enableCheckIgnore, uint debugButton, bool ignoreButton, sint quitButton, bool sendReportButton, bool &ignoreNextTime)
void report ()
template<class T> void rotateCCW (const T *src, T *dst, uint srcWidth, uint srcHeight)
template<class T, class U> T safe_cast (U o)
void ScanEdge (CPolygon2D::TRasterVect &outputVect, sint topY, const CVector2f &v1, const CVector2f &v2, bool rightEdge=true)
***************************************************************************************

void ScanInnerEdge (CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY, bool rightEdge)
void ScanOuterEdgeLeft (CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY)
void ScanOuterEdgeRight (CPolygon2D::TRaster *r, float x1, float y1, float x2, float y2, sint minY)
template<class T> uint searchLowerBound (const std::vector< T > &array, const T &key)
template<class T> uint searchLowerBound (const T *array, uint arraySize, const T &key)
string secondsToHumanReadable (uint32 time)
Convert a time into a string that is easily readable by an human, for example 3600 -> "1h".

void setAssert (bool assert)
void setCrashCallback (TCrashCallback crashCallback)
void setReportEmailFunction (void *emailFunction)
char * skipToken (const char *p)
char * skipWS (const char *p)
sint smprintf (char *buffer, size_t count, const char *format,...)
void splitString (const std::string &str, const std::string &separator, std::vector< std::string > &retList)
template<class T> T sqr (const T &v)
template<class T, class U> bool strFindReplace (T &str, const char *strFind, const U &strReplace)
template<class T, class U> bool strFindReplace (T &str, const T &strFind, const U &strReplace)
In a string or ucstring, find a substr and replace it with an other. return true if replaced.

int stricmp (const char *lhs, const char *rhs)
std::string stringFromVector (const std::vector< uint8 > &v, bool limited=true)
Returns a readable string from a vector of bytes. unprintable char are replaced by '?'.

string stringFromVector (const vector< uint8 > &v, bool limited)
char * strlwr (char *str)
std::string & strlwr (std::string &str)
std::string strlwr (const std::string &str)
char * strupr (char *str)
std::string strupr (const std::string &str)
std::string & strupr (std::string &str)
bool testWildCard (const char *strIn, const char *wildCard)
bool testWildCard (const std::string &strIn, const std::string &wildCard)
std::string toString (const std::string &val)
std::string toString (const bool &val)
std::string toString (const double &val)
std::string toString (const float &val)
std::string toString (const sint64 &val)
std::string toString (const uint64 &val)
std::string toString (const sint32 &val)
std::string toString (const uint32 &val)
std::string toString (const sint16 &val)
std::string toString (const uint16 &val)
std::string toString (const sint8 &val)
std::string toString (const uint8 &val)
template<class T> std::string toString (const T &obj)
std::string toString (const char *format,...)
std::string toString (NL3D::CPSEmitter::TEmissionType type)
template<class T> std::string toStringEnum (const T &val)
template<class T> std::string toStringPtr (const T *val)
template<class T, class U> T type_cast (U o)
void xmlGenericErrorFuncRead (void *ctx, const char *msg,...)
void xmlGenericErrorFuncWrite (void *ctx, const char *msg,...)
int xmlOutputCloseCallbackForNeL (void *context)
int xmlOutputWriteCallbackForNeL (void *context, const char *buffer, int len)

Variables
CLog * AssertLog = NULL
string BasePathgetPathContent
const uint32 BF_ALWAYS_OPENED = 0x00000001
const uint32 BF_CACHE_FILE_ON_OPEN = 0x00000002
TCrashCallback CrashCallback = NULL
const uint32 DDS = ((uint32)(uint8)( 'D' ) | ((uint32)(uint8)( 'D' ) << 8) | ((uint32)(uint8)( 'S' ) << 16) | ((uint32)(uint8)( ) << 24 ))
CLog * DebugLog = NULL
bool DebugNeedAssert = false
CMemDisplayer * DefaultMemDisplayer = NULL
CMsgBoxDisplayer * DefaultMsgBoxDisplayer = NULL
const uint32 DXT_ = ((uint32)(uint8)( 'D' ) | ((uint32)(uint8)( 'X' ) << 8) | ((uint32)(uint8)( 'T' ) << 16) | ((uint32)(uint8)( '\0' ) << 24 ))
TEmailFunction EmailFunction = NULL
CLog * ErrorLog = NULL
const CClassId EventActivateId (0x7da66b0a, 0x1ef74519)
const CClassId EventCharId (0x552255fe, 0x75a2373f)
const CClassId EventDestroyWindowId (0x69be73fe, 0x4b07603b)
const CClassId EventGDAxisMovedId (0x073306, 0x41173626)
const CClassId EventGDButtonDownId (0x57141957, 0x3efb143a)
const CClassId EventGDButtonUpId (0x16105e06, 0x302536b2)
const CClassId EventGDMouseMove (0x12142bc4, 0x43c73e74)
const CClassId EventGDPOVChanged (0x362851b9, 0x395c4d61)
const CClassId EventGDSliderMovedId (0x68776586, 0x394a6916)
const CClassId EventKeyDownId (0x3c2643da, 0x43f802a1)
const CClassId EventKeyUpId (0x1e62e85, 0x68a35d46)
const CClassId EventMouseDblClkId (0x55a94cb3, 0x3e641517)
const CClassId EventMouseDownId (0x35b7878, 0x5d4a0f86)
const CClassId EventMouseMoveId (0x3dd12fdb, 0x472f548b)
const CClassId EventMouseUpId (0xcce1f7e, 0x7ed344d7)
const CClassId EventMouseWheelId (0x73ac4321, 0x4c273150)
const CClassId EventSetFocusId (0x17650fac, 0x19f85dde)
CFileDisplayer * fd = NULL
vector< CFileEntry > FileToCheck
bool GlobalAssertCall = false
bool HasMMX = DetectMMX()
bool HasSSE = DetectSSE()
CLog * InfoLog = NULL
char JPGBuffer [JPGBufferSize]
const uint32 JPGBufferSize = 1000
NLMISC::IStream * JPGStream = NULL
const char * LogTypeToString [][8]
const uint8 MAX_MIPMAP = 16
const int MaxCStringSize = 1024*2
bool NL3D_BlockMemoryAssertOnPurge = true
See CBlockMemory::Purge.

const float NL3D_OO255 = 1.0f / 255
CRandomGrid3D NL3D_RandomGrid3D
bool NoAssert = false
int OptFastFloorBkupCW
int OptFastFloorBkupCW24
double OptFastFloorMagicConst = pow(2,52) + pow(2,51)
float OptFastFloorMagicConst24 = (float)pow(2,23)
const double Pi = 3.1415926535897932384626433832795
const double QuatEpsilon = 0.000001
CStdDisplayer * sd = NULL
const int SEP_SIZE = 1
const char SEPARATOR = ' '
const char * SerialTypeToCStr [TBMSSerialInfo::NbSerialTypes] = { "Bool ", "Ui32N", "Ui64N", "Float", "Btfld", "Buffr" }
map< TSharedMemId, int > SharedMemIdsToShmids
const CStringConversion< TKey
+>::CPair stringTable []
CLog * WarningLog = NULL
+

Typedef Documentation

+ + + + +
+ + +
typedef CFastMutex NLMISC::CAllocatorMutex +
+
+ + + + + +
+ + + +
+ +
+Definition at line 56 of file include/nel/misc/heap_allocator.h.
+

+ + + + +
+ + +
typedef std::multimap<CClassId, IEventListener*> NLMISC::mapListener +
+
+ + + + + +
+ + + +
+ +
+Definition at line 43 of file event_server.h.
+

+ + + + +
+ + +
typedef void*(* NLMISC::memcpyPtr)(void *dts, const void *src, size_t nbytes) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 225 of file fast_mem.cpp. +
+Referenced by findBestmemcpy().
+

+ + + + +
+ + +
typedef std::vector< TBMSSerialInfo > NLMISC::TBMSSerialInfoList +
+
+ + + + + +
+ + + +
+ +
+Definition at line 153 of file bit_mem_stream.h.
+

+ + + + +
+ + +
typedef std::map<float, CConcavePolygonsVertexDesc> NLMISC::TCConcavePolygonsVertexMap +
+
+ + + + + +
+ + + +
+ +
+Definition at line 173 of file polygon.cpp. +
+Referenced by NLMISC::CPolygon::toConvexPolygonsLocalAndBSP().
+

+ + + + +
+ + +
typedef sint64 NLMISC::TCPUCycle +
+
+ + + + + +
+ + + +
+ +
+Definition at line 44 of file time_nl.h.
+

+ + + + +
+ + +
typedef std::string(* NLMISC::TCrashCallback)() +
+
+ + + + + +
+ + + +
+ +
+Definition at line 75 of file debug.h. +
+Referenced by setCrashCallback().
+

+ + + + +
+ + +
typedef std::vector<CGameDeviceDesc> NLMISC::TDeviceDescVect +
+
+ + + + + +
+ + + +
+ +
+Definition at line 52 of file game_device.h.
+

+ + + + +
+ + +
typedef bool(* NLMISC::TEmailFunction)(const std::string &smtpServer, const std::string &from, const std::string &to, const std::string &subject, const std::string &body, const std::string &attachedFile = "", bool onlyCheck = false) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 61 of file report.cpp. +
+Referenced by setReportEmailFunction().
+

+ + + + +
+ + +
typedef uint32 NLMISC::TGameCycle +
+
+ + + + + +
+ + + +
+ +
+Definition at line 42 of file time_nl.h.
+

+ + + + +
+ + +
typedef double NLMISC::TGameTime +
+
+ + + + + +
+ + + +
+New time types. +
+ +
+Definition at line 41 of file time_nl.h.
+

+ + + + +
+ + +
typedef std::map<std::string, CLeak> NLMISC::TLinkMap +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1914 of file misc/heap_allocator.cpp. +
+Referenced by NLMISC::CHeapAllocator::debugReportMemoryLeak().
+

+ + + + +
+ + +
typedef double NLMISC::TLocalTime +
+
+ + + + + +
+ + + +
+ +
+Definition at line 43 of file time_nl.h.
+

+ + + + +
+ + +
typedef uint32 NLMISC::TMsDuration +
+
+ + + + + +
+ + + +
+ +
+Definition at line 38 of file stop_watch.h. +
+Referenced by NLMISC::CStopWatch::getAverageDuration(), NLMISC::CStopWatch::getDuration(), and NLMISC::CStopWatch::getPartialAverage().
+

+ + + + +
+ + +
typedef key_t NLMISC::TSharedMemId +
+
+ + + + + +
+ + + +
+ +
+Definition at line 41 of file shared_memory.h. +
+Referenced by NLMISC::CSharedMemory::accessSharedMemory(), NLMISC::CSharedMemory::createSharedMemory(), and NLMISC::CSharedMemory::destroySharedMemory().
+

+ + + + +
+ + +
typedef uint NLMISC::TSStringId +
+
+ + + + + +
+ + + +
+ +
+Definition at line 104 of file string_mapper.h. +
+Referenced by NLMISC::CStaticStringMapper::add(), NLMISC::CStaticStringMapper::emptyId(), NLMISC::CStaticStringMapper::get(), NLMISC::CStaticStringMapper::memoryUncompress(), and NLMISC::CStaticStringMapper::serial().
+

+ + + + +
+ + +
typedef uint NLMISC::TStringId +
+
+ + + + + +
+ + + +
+ +
+Definition at line 42 of file string_mapper.h.
+

+ + + + +
+ + +
typedef uint32 NLMISC::TTickDuration +
+
+ + + + + +
+ + + +
+ +
+Definition at line 37 of file stop_watch.h. +
+Referenced by NLMISC::CStopWatch::addMeasurement(), NLMISC::CStopWatch::addTime(), NLMISC::CStopWatch::pause(), NLMISC::CStopWatch::stop(), and NLMISC::CStopWatch::sumTicks().
+

+ + + + +
+ + +
typedef sint64 NLMISC::TTicks +
+
+ + + + + +
+ + + +
+ +
+Definition at line 48 of file time_nl.h. +
+Referenced by NL3D::CDriverGL::appendVBHardLockProfile(), NLPACS::CGlobalRetriever::findAStarPath(), NLPACS::CGlobalRetriever::findPath(), NLMISC::CBufFIFO::front(), NLMISC::CTime::getPerformanceTime(), NLSOUND::CSimpleSource::getPlayTime(), NLMISC::CSystemInfo::getProcessorFrequency(), NL3D::CVertexBufferHardGLNVidia::lock(), NLMISC::CBufFIFO::push(), NLMISC::CBufFIFO::resize(), NLAIAGENT::CAgentScript::run(), NLAIAGENT::CAgentClockTimer::runActivity(), NLAIAGENT::CAgentWatchTimer::runActivity(), NLMISC::CTime::ticksToSecond(), and NLSOUND::CSoundDriverDSound::update().
+

+ + + + +
+ + +
typedef sint64 NLMISC::TTime +
+
+ + + + + +
+ + + +
+Old time type. +
+ +
+Definition at line 47 of file time_nl.h. +
+Referenced by NLSOUND::CAudioMixerUser::addEvent(), NLNET::CCallbackNetBase::baseUpdate(), NLNET::cbServerAskUniversalTime(), NLNET::CUdpSimSock::dataAvailable(), NLMISC::CTime::getLocalTime(), NLNET::_CUniTime::getStringUniTime(), NLSOUND::CComplexSource::getTime(), NLNET::_CUniTime::getUniTime(), loadForm(), NLNET::IService::main(), NLSOUND::CComplexSource::onEvent(), NLSOUND::CComplexSource::onUpdate(), NLSOUND::CComplexSource::playStuf(), NLAIAGENT::CAgentManagerTimer::CRunTimer::run(), NLNET::CUdpSimSock::sendUDP(), NLNET::_CUniTime::setUniTime(), NLNET::IService::setUpdateTimeout(), NLMISC::CTime::ticksToSecond(), NLSOUND::CSoundDriverDSound::TimerCallback(), NLNET::CUnifiedNetwork::update(), NLSOUND::CSoundDriverDSound::update(), NLNET::CNetManager::update(), NLNET::CBufSock::update(), and NLNET::CUdpSimSock::updateBufferizedPackets().
+

Enumeration Type Documentation

+ + + + +
+ + +
enum NLMISC::TKey +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Key0 +
Key1 +
Key2 +
Key3 +
Key4 +
Key5 +
Key6 +
Key7 +
Key8 +
Key9 +
KeyA +
KeyB +
KeyC +
KeyD +
KeyE +
KeyF +
KeyG +
KeyH +
KeyI +
KeyJ +
KeyK +
KeyL +
KeyM +
KeyN +
KeyO +
KeyP +
KeyQ +
KeyR +
KeyS +
KeyT +
KeyU +
KeyV +
KeyW +
KeyX +
KeyY +
KeyZ +
KeyLBUTTON +
KeyRBUTTON +
KeyCANCEL +
KeyMBUTTON +
KeyBACK +
KeyTAB +
KeyCLEAR +
KeyRETURN +
KeySHIFT +
KeyCONTROL +
KeyMENU +
KeyPAUSE +
KeyCAPITAL +
KeyKANA +
KeyHANGEUL +
KeyHANGUL +
KeyJUNJA +
KeyFINAL +
KeyHANJA +
KeyKANJI +
KeyESCAPE +
KeyCONVERT +
KeyNONCONVERT +
KeyACCEPT +
KeyMODECHANGE +
KeySPACE +
KeyPRIOR +
KeyNEXT +
KeyEND +
KeyHOME +
KeyLEFT +
KeyUP +
KeyRIGHT +
KeyDOWN +
KeySELECT +
KeyPRINT +
KeyEXECUTE +
KeySNAPSHOT +
KeyINSERT +
KeyDELETE +
KeyHELP +
KeyLWIN +
KeyRWIN +
KeyAPPS +
KeyNUMPAD0 +
KeyNUMPAD1 +
KeyNUMPAD2 +
KeyNUMPAD3 +
KeyNUMPAD4 +
KeyNUMPAD5 +
KeyNUMPAD6 +
KeyNUMPAD7 +
KeyNUMPAD8 +
KeyNUMPAD9 +
KeyMULTIPLY +
KeyADD +
KeySEPARATOR +
KeySUBTRACT +
KeyDECIMAL +
KeyDIVIDE +
KeyF1 +
KeyF2 +
KeyF3 +
KeyF4 +
KeyF5 +
KeyF6 +
KeyF7 +
KeyF8 +
KeyF9 +
KeyF10 +
KeyF11 +
KeyF12 +
KeyF13 +
KeyF14 +
KeyF15 +
KeyF16 +
KeyF17 +
KeyF18 +
KeyF19 +
KeyF20 +
KeyF21 +
KeyF22 +
KeyF23 +
KeyF24 +
KeyNUMLOCK +
KeySCROLL +
KeyLSHIFT +
KeyRSHIFT +
KeyLCONTROL +
KeyRCONTROL +
KeyLMENU +
KeyRMENU +
KeySEMICOLON +
KeyEQUALS +
KeyCOMMA +
KeyDASH +
KeyPERIOD +
KeySLASH +
KeyTILDE +
KeyLBRACKET +
KeyBACKSLASH +
KeyRBRACKET +
KeyAPOSTROPHE +
KeyPROCESSKEY +
KeyATTN +
KeyCRSEL +
KeyEXSEL +
KeyEREOF +
KeyPLAY +
KeyZOOM +
KeyNONAME +
KeyPA1 +
KeyOEM_CLEAR +
KeyCount +
+
+ +
+Definition at line 81 of file events.h. +
+Referenced by NLMISC::CEventKey::getKeyFromString(). +
+
00082 { +00083 Key0 ='0', +00084 Key1 ='1', +00085 Key2 ='2', +00086 Key3 ='3', +00087 Key4 ='4', +00088 Key5 ='5', +00089 Key6 ='6', +00090 Key7 ='7', +00091 Key8 ='8', +00092 Key9 ='9', +00093 KeyA ='A', +00094 KeyB ='B', +00095 KeyC ='C', +00096 KeyD ='D', +00097 KeyE ='E', +00098 KeyF ='F', +00099 KeyG ='G', +00100 KeyH ='H', +00101 KeyI ='I', +00102 KeyJ ='J', +00103 KeyK ='K', +00104 KeyL ='L', +00105 KeyM ='M', +00106 KeyN ='N', +00107 KeyO ='O', +00108 KeyP ='P', +00109 KeyQ ='Q', +00110 KeyR ='R', +00111 KeyS ='S', +00112 KeyT ='T', +00113 KeyU ='U', +00114 KeyV ='V', +00115 KeyW ='W', +00116 KeyX ='X', +00117 KeyY ='Y', +00118 KeyZ ='Z', +00119 KeyLBUTTON =0x01, +00120 KeyRBUTTON =0x02, +00121 KeyCANCEL =0x03, +00122 KeyMBUTTON =0x04, +00123 KeyBACK =0x08, +00124 KeyTAB =0x09, +00125 KeyCLEAR =0x0C, +00126 KeyRETURN =0x0D, +00127 KeySHIFT =0x10, +00128 KeyCONTROL =0x11, +00129 KeyMENU =0x12, +00130 KeyPAUSE =0x13, +00131 KeyCAPITAL =0x14, +00132 KeyKANA =0x15, +00133 KeyHANGEUL =0x15, +00134 KeyHANGUL =0x15, +00135 KeyJUNJA =0x17, +00136 KeyFINAL =0x18, +00137 KeyHANJA =0x19, +00138 KeyKANJI =0x19, +00139 KeyESCAPE =0x1B, +00140 KeyCONVERT =0x1C, +00141 KeyNONCONVERT =0x1D, +00142 KeyACCEPT =0x1E, +00143 KeyMODECHANGE =0x1F, +00144 KeySPACE =0x20, +00145 KeyPRIOR =0x21, +00146 KeyNEXT =0x22, +00147 KeyEND =0x23, +00148 KeyHOME =0x24, +00149 KeyLEFT =0x25, +00150 KeyUP =0x26, +00151 KeyRIGHT =0x27, +00152 KeyDOWN =0x28, +00153 KeySELECT =0x29, +00154 KeyPRINT =0x2A, +00155 KeyEXECUTE =0x2B, +00156 KeySNAPSHOT =0x2C, +00157 KeyINSERT =0x2D, +00158 KeyDELETE =0x2E, +00159 KeyHELP =0x2F, +00160 KeyLWIN =0x5B, +00161 KeyRWIN =0x5C, +00162 KeyAPPS =0x5D, +00163 KeyNUMPAD0 =0x60, +00164 KeyNUMPAD1 =0x61, +00165 KeyNUMPAD2 =0x62, +00166 KeyNUMPAD3 =0x63, +00167 KeyNUMPAD4 =0x64, +00168 KeyNUMPAD5 =0x65, +00169 KeyNUMPAD6 =0x66, +00170 KeyNUMPAD7 =0x67, +00171 KeyNUMPAD8 =0x68, +00172 KeyNUMPAD9 =0x69, +00173 KeyMULTIPLY =0x6A, +00174 KeyADD =0x6B, +00175 KeySEPARATOR =0x6C, +00176 KeySUBTRACT =0x6D, +00177 KeyDECIMAL =0x6E, +00178 KeyDIVIDE =0x6F, +00179 KeyF1 =0x70, +00180 KeyF2 =0x71, +00181 KeyF3 =0x72, +00182 KeyF4 =0x73, +00183 KeyF5 =0x74, +00184 KeyF6 =0x75, +00185 KeyF7 =0x76, +00186 KeyF8 =0x77, +00187 KeyF9 =0x78, +00188 KeyF10 =0x79, +00189 KeyF11 =0x7A, +00190 KeyF12 =0x7B, +00191 KeyF13 =0x7C, +00192 KeyF14 =0x7D, +00193 KeyF15 =0x7E, +00194 KeyF16 =0x7F, +00195 KeyF17 =0x80, +00196 KeyF18 =0x81, +00197 KeyF19 =0x82, +00198 KeyF20 =0x83, +00199 KeyF21 =0x84, +00200 KeyF22 =0x85, +00201 KeyF23 =0x86, +00202 KeyF24 =0x87, +00203 KeyNUMLOCK =0x90, +00204 KeySCROLL =0x91, +00205 KeyLSHIFT =0xA0, +00206 KeyRSHIFT =0xA1, +00207 KeyLCONTROL =0xA2, +00208 KeyRCONTROL =0xA3, +00209 KeyLMENU =0xA4, +00210 KeyRMENU =0xA5, +00211 KeySEMICOLON =0xBA, +00212 KeyEQUALS =0xBB, +00213 KeyCOMMA =0xBC, +00214 KeyDASH =0xBD, +00215 KeyPERIOD =0xBE, +00216 KeySLASH =0xBF, +00217 KeyTILDE =0xC0, +00218 KeyLBRACKET =0xDB, +00219 KeyBACKSLASH =0xDC, +00220 KeyRBRACKET =0xDD, +00221 KeyAPOSTROPHE =0xDE, +00222 KeyPROCESSKEY =0xE5, +00223 KeyATTN =0xF6, +00224 KeyCRSEL =0xF7, +00225 KeyEXSEL =0xF8, +00226 KeyEREOF =0xF9, +00227 KeyPLAY =0xFA, +00228 KeyZOOM =0xFB, +00229 KeyNONAME =0xFC, +00230 KeyPA1 =0xFD, +00231 KeyOEM_CLEAR =0xFE, +00232 KeyCount =0xFF +00233 }; +

+

+ + + + +
+ + +
enum NLMISC::TKeyButton +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + + +
noKeyButton +
ctrlKeyButton +
shiftKeyButton +
altKeyButton +
+
+ +
+Definition at line 246 of file events.h. +
+
00247 { +00248 noKeyButton =0x0, +00249 ctrlKeyButton =0x8, +00250 shiftKeyButton =0x10, +00251 altKeyButton =0x20 +00252 }; +

+

+ + + + +
+ + +
enum NLMISC::TMouseButton +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + + + + + +
noButton +
leftButton +
middleButton +
rightButton +
ctrlButton +
shiftButton +
altButton +
+
+ +
+Definition at line 235 of file events.h. +
+
00236 { +00237 noButton =0x0, +00238 leftButton =0x1, +00239 middleButton =0x2, +00240 rightButton =0x4, +00241 ctrlButton =0x8, +00242 shiftButton =0x10, +00243 altButton =0x20 +00244 }; +

+

+ + + + +
+ + +
enum NLMISC::TReportResult +
+
+ + + + + +
+ + + +
+Display a custom message box.
+
Parameters:
+ + + + + +
title set the title of the report. If empty, it'll display "NeL report".
header message displayed before the edit text box. If empty, it displays the default message.
body message displayed in the edit text box. This string will be sent by email.
debugButton 0 for disabling it, 1 for enable with default behaviors (generate a breakpoint), 2 for enable with no behavior
+
+
Returns:
the button clicked or error
+
Enumeration values:
+ + + + + +
ReportDebug +
ReportIgnore +
ReportQuit +
ReportError +
+
+ +
+Definition at line 46 of file report.h. +
+
00046 { ReportDebug, ReportIgnore, ReportQuit, ReportError }; +

+

Function Documentation

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::addSlashR ( std::string str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 35 of file string_common.cpp. +
+References uint. +
+
00036 { +00037 string formatedStr; +00038 // replace \n with \r\n +00039 for (uint i = 0; i < str.size(); i++) +00040 { +00041 if (str[i] == '\n' && i > 0 && str[i-1] != '\r') +00042 { +00043 formatedStr += '\r'; +00044 } +00045 formatedStr += str[i]; +00046 } +00047 return formatedStr; +00048 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NLMISC::atoihex ( const char * ident ) [inline]
+
+ + + + + +
+ + + +
+
Todo:
cado: NLMISC::CStringStream: Use strtoul() functions instead of atoi(), to handle conversion errors
+ +
+Definition at line 102 of file string_stream.cpp. +
+Referenced by NLMISC::CStringStream::serialHex(), and NLMISC::CMemStream::serialHex(). +
+
00103 { +00104 int number; +00105 sscanf( ident, "%x", &number ); +00106 return number; +00107 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint64 NLMISC::atoiInt64 ( const char * ident,
sint64 base = 10
)
+
+ + + + + +
+ + + +
+Convert a string into an sint64 (same as atoi() function but for 64 bits intergers). +
+old sameh algo +
+Definition at line 178 of file common.cpp. +
+References nlassert, and sint64. +
+Referenced by bytesToHumanReadable(). +
+
00179 { +00180 sint64 number = 0; +00181 bool neg = false; +00182 +00183 // NULL string +00184 nlassert (ident != NULL); +00185 +00186 // empty string +00187 if (*ident == '\0') goto end; +00188 +00189 // + sign +00190 if (*ident == '+') ident++; +00191 +00192 // - sign +00193 if (*ident == '-') { neg = true; ident++; } +00194 +00195 while (*ident != '\0') +00196 { +00197 if (isdigit(*ident)) +00198 { +00199 number *= base; +00200 number += (*ident)-'0'; +00201 } +00202 else if (base > 10 && islower(*ident)) +00203 { +00204 number *= base; +00205 number += (*ident)-'a'+10; +00206 } +00207 else if (base > 10 && isupper(*ident)) +00208 { +00209 number *= base; +00210 number += (*ident)-'A'+10; +00211 } +00212 else +00213 { +00214 goto end; +00215 } +00216 ident++; +00217 } +00218 end: +00219 if (neg) number = -number; +00220 return number; +00221 +00223 /* uint64 k = 0; +00224 +00225 while (*ident != '\0') +00226 { +00227 switch(*(ident++)) +00228 { +00229 case '0': +00230 k +=0; +00231 break; +00232 case '1': +00233 k +=1; +00234 break; +00235 case '2': +00236 k +=2; +00237 break; +00238 case '3': +00239 k +=3; +00240 break; +00241 case '4': +00242 k +=4; +00243 break; +00244 case '5': +00245 k +=5; +00246 break; +00247 case '6': +00248 k +=6; +00249 break; +00250 case '7': +00251 k +=7; +00252 break; +00253 case '8': +00254 k +=8; +00255 break; +00256 case '9': +00257 k +=9; +00258 break; +00259 case 'a': +00260 k +=10; +00261 break; +00262 case 'b': +00263 k +=11; +00264 break; +00265 case 'c': +00266 k +=12; +00267 break; +00268 case 'd': +00269 k +=13; +00270 break; +00271 case 'e': +00272 k +=14; +00273 break; +00274 case 'f': +00275 k +=15; +00276 break; +00277 +00278 case 'A': +00279 k +=10; +00280 break; +00281 case 'B': +00282 k +=11; +00283 break; +00284 case 'C': +00285 k +=12; +00286 break; +00287 case 'D': +00288 k +=13; +00289 break; +00290 case 'E': +00291 k +=14; +00292 break; +00293 case 'F': +00294 k +=15; +00295 break; +00296 +00297 case 0: +00298 return k; +00299 break; +00300 } +00301 if(*ident != 0) k *= base; +00302 } +00303 +00304 return k; +00305 */ +00306 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NLMISC::atoui ( const char * ident ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 481 of file i_xml.cpp. +
+References atoui(), and uint32. +
+Referenced by atoui(), NLMISC::CStringStream::serial(), and NLMISC::CMemStream::serial(). +
+
00482 { +00483 return (uint32) strtoul (ident, NULL, 10); +00484 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::beep ( uint freq,
uint duration
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 974 of file debug.cpp. +
+References uint. +
+Referenced by NLNET::IService::main(). +
+
00975 { +00976 #ifdef NL_OS_WINDOWS +00977 Beep( freq, duration ); +00978 #endif +00979 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
uint32 blend ( uint32 & n0,
uint32 & n1,
uint32 coef0
)
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void blendFromui ( NLMISC::CRGBA & c0,
NLMISC::CRGBA & c1,
uint coef
)
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void BuildHermiteVector ( const NLMISC::CVector2f & P0,
const NLMISC::CVector2f & P1,
const NLMISC::CVector2f & T0,
const NLMISC::CVector2f & T1,
NLMISC::CVector2f & dest,
float lambda
) [inline, static]
+
+ + + + + +
+ + + +
+build some hermite spline value, with the given points and tangents +
+just avoid some ctor calls here... +
+Definition at line 33 of file mouse_smoother.cpp. +
+References NLMISC::CVector2f::set(), NLMISC::CVector2f::x, and NLMISC::CVector2f::y. +
+Referenced by NLMISC::CMouseSmoother::samplePos(). +
+
00040 { +00041 const float lambda2 = lambda * lambda; +00042 const float lambda3 = lambda2 * lambda; +00043 const float h1 = 2 * lambda3 - 3 * lambda2 + 1; +00044 const float h2 = - 2 * lambda3 + 3 * lambda2; +00045 const float h3 = lambda3 - 2 * lambda2 + lambda; +00046 const float h4 = lambda3 - lambda2; +00048 dest.set(h1 * P0.x + h2 * P1.x + h3 * T0.x + h4 * T1.x, +00049 h1 * P0.y + h2 * P1.y + h3 * T0.y + h4 * T1.y); +00050 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::bytesToHumanReadable ( uint32 bytes )
+
+ + + + + +
+ + + +
+ +
+Definition at line 405 of file common.cpp. +
+References res, toString(), uint, and uint32. +
+
00406 { +00407 static char *divTable[]= { "b", "kb", "mb", "gb" }; +00408 uint div = 0; +00409 uint32 res = bytes; +00410 uint32 newres = res; +00411 while (true) +00412 { +00413 newres /= 1024; +00414 if(newres < 8 || div > 2) +00415 break; +00416 div++; +00417 res = newres; +00418 } +00419 return toString ("%u%s", res, divTable[div]); +00420 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::bytesToHumanReadable ( const std::string & bytes )
+
+ + + + + +
+ + + +
+Convert a number in bytes into a string that is easily readable by an human, for example 105123 -> "102kb". +
+ +
+Definition at line 388 of file common.cpp. +
+References atoiInt64(), NL_I64, res, toString(), uint, and uint64. +
+Referenced by NLMISC_COMMAND(), and NLMISC_DYNVARIABLE(). +
+
00389 { +00390 static char *divTable[]= { "b", "kb", "mb", "gb" }; +00391 uint div = 0; +00392 uint64 res = atoiInt64(bytes.c_str()); +00393 uint64 newres = res; +00394 while (true) +00395 { +00396 newres /= 1024; +00397 if(newres < 8 || div > 2) +00398 break; +00399 div++; +00400 res = newres; +00401 } +00402 return toString ("%"NL_I64"u%s", res, divTable[div]); +00403 } +

+

+ + + + +
+ + + + + + + + + + +
void cbInvalidEntityNamesFilename ( const std::string & invalidEntityNamesFilename )
+
+ + + + + +
+ + + +
+ +
+Definition at line 370 of file eid_translator.cpp. +
+References NLMISC::CEntityIdTranslator::InvalidEntityNames, and nlwarning. +
+Referenced by NLMISC::CEntityIdTranslator::load(). +
+
00371 { +00372 CEntityIdTranslator::getInstance()->InvalidEntityNames.clear (); +00373 +00374 string fn = CPath::lookup(invalidEntityNamesFilename, false); +00375 +00376 if (fn.empty()) +00377 { +00378 nlwarning ("EIT: Can't load filename '%s' for invalid entity names filename (not found)", invalidEntityNamesFilename.c_str()); +00379 return; +00380 } +00381 +00382 FILE *fp = fopen (fn.c_str(), "r"); +00383 if (fp == NULL) +00384 { +00385 nlwarning ("EIT: Can't load filename '%s' for invalid entity names filename", fn.c_str()); +00386 return; +00387 } +00388 +00389 while (true) +00390 { +00391 char str[512]; +00392 fgets(str, 511, fp); +00393 if(feof(fp)) +00394 break; +00395 if (strlen(str) > 0) +00396 { +00397 str[strlen(str)-1] = '\0'; +00398 CEntityIdTranslator::getInstance()->InvalidEntityNames.push_back(str); +00399 } +00400 } +00401 +00402 fclose (fp); +00403 } +

+

+ + + + +
+ + + + + + + + + + +
void cbVarChanged ( CConfigFile::CVar & cvar )
+
+ + + + + +
+ + + +
+ +
+Definition at line 36 of file variable.cpp. +
+References NLMISC::CConfigFile::CVar::asString(), NLMISC::IVariable::fromString(), NLMISC::CConfigFile::CVar::Name, and nlinfo. +
+Referenced by NLMISC::IVariable::init(). +
+
00037 { +00038 for (ICommand::TCommand::iterator comm = (*ICommand::Commands).begin(); comm != (*ICommand::Commands).end(); comm++) +00039 { +00040 if ((*comm).second->Type == ICommand::Variable && (*comm).second->_CommandName == cvar.Name) +00041 { +00042 IVariable *var = (IVariable *)((*comm).second); +00043 string val = cvar.asString(); +00044 nlinfo ("VAR: Setting variable '%s' with value '%s' from config file", cvar.Name.c_str(), val.c_str()); +00045 var->fromString(val, true); +00046 } +00047 } +00048 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::changeLogDirectory ( const std::string & dir )
+
+ + + + + +
+ + + +
+ +
+Definition at line 893 of file debug.cpp. +
+References fd, and NLMISC::CFileDisplayer::setParam(). +
+Referenced by NLNET::IService::main(). +
+
00894 { +00895 if (fd == NULL)return; +00896 string p = CPath::standardizePath(dir) + "log.log"; +00897 fd->setParam(p); +00898 } +

+

+ + + + +
+ + + + + + + + + + +
void CHeapAllocatorOutputError ( const char * str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 59 of file misc/heap_allocator.cpp. +
+Referenced by NLMISC::CHeapAllocator::debugReportMemoryLeak(). +
+
00060 { +00061 fprintf (stderr, str); +00062 #ifdef NL_OS_WINDOWS +00063 OutputDebugString (str); +00064 #endif // NL_OS_WINDOWS +00065 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T, class U, class V>
void clamp ( T & v,
const U & min,
const V & max
) [inline]
+
+ + + + + +
+ + + +
+Force v to be inside the interval [min,max]. Warning: implicit cast are made if T,U or V are different. +
+Definition at line 115 of file common.h. +
+References min, and v. +
+Referenced by NL3D::CVisualCollisionManager::CStaticGrid::add(), NL3D::CLodCharacterShape::addAnim(), NL3D::CQuadGridClipCluster::addModel(), NLSOUND::CBackgroundSoundManager::addSound(), NL3D::CPatch::appendTileLightInfluences(), NL3D::CMeshMRMSkinnedGeom::applyGeomorphWithVBHardPtr(), NL3D::CMeshMRMGeom::applyGeomorphWithVBHardPtr(), NL3D::CMRMBuilder::attToColor(), NL3D::CMeshVPWindTree::begin(), NL3D::CMeshVPWindTree::beginMBRInstance(), NL3D::CTextureFile::buildBitmapFromFile(), NLMISC::CRGBA::buildFromHLS(), NL3D::CZoneLighter::calcSkyContribution(), NLMISC::CVectorD::cartesianToSpheric(), NLMISC::CVector::cartesianToSpheric(), NL3D::CFastHLSModifier::CFastHLSModifier(), NL3D::CQuadGridClipClusterQTreeNode::clip(), NL3D::CDriverGL::clipRect(), NL3D::CPatch::computeDisplaceRawInteger(), NL3D::CPatch::computeGeomorphAlphaFar1VertexListVB(), NL3D::CTessVertex::computeGeomPos(), NL3D::CPointLight::computeLinearAttenuation(), NL3D::CLightingManager::computeModelLightContributions(), NL3D::CLoadBalancingGroup::computeRatioAndSmooth(), NL3D::CPSParticle::computeSrcStep(), NL3D::CPatch::computeTileLightmapPixelAutomatic(), NL3D::CFastHLSModifier::convertRGBABitmap(), NLGEORGES::CFormElm::convertValue(), NL3D::copyToValue(), NL3D::CRadixSort< T >::CRadixSort(), NL3D::CTileLumel::createUncompressed(), NL3D::CTextureEmboss::doGenerate(), NLPACS::CGlobalRetriever::doMove(), NLMISC::CNoiseColorGradient::eval(), CTrackKeyFramerTCB< CKeyTCBQuat, NLMISC::CAngleAxis >::evalKey(), CTrackKeyFramerTCB< CKeyT, T >::evalKey(), NL3D::CTrackKeyFramerLinear< CKeyQuat, CQuat >::evalKey(), NL3D::CTrackKeyFramerLinear< CKeyRGBA, NLMISC::CRGBA >::evalKey(), CTrackKeyFramerBezier< CKeyBezierQuat, CQuat >::evalKey(), CTrackKeyFramerBezier< CKeyT, T >::evalKey(), NL3D::CTrackSampledCommon::evalTime(), NL3D::CTargetAnimCtrl::execute(), NL3D::fastClamp01(), fastClamp8(), NL3D::CDriverGL::forceTextureResize(), NL3D::CPatchDLMContext::generate(), NL3D::CPatch::generateTileVegetable(), NLSOUND::CClusteredSound::getAABoxNearestPos(), NL3D::CLodCharacterShape::getAnimKey(), NLMISC::CBitmap::getColorInterp(), NL3D::CMRMLevelDetail::getLevelDetailFromPolyCount(), NL3D::CAnimationPlaylist::getLocalTime(), NL3D::CPatch::getLumel(), NL3D::CZoneLighter::getMaxPhi(), NL3D::CDriverGL::getSpecularCubeMap(), NL3D::CSurfaceLightGrid::getStaticLightSetup(), NL3D::CPatch::getTesselatedPos(), NL3D::CZoneLighter::getTexture(), NL3D::CPatch::getTileElement(), NL3D::CPSFloatCurveFunctor::getValue(), NL3D::CViewport::init(), NL3D::CTessFacePriorityList::init(), NL3D::CZoneLighter::lightWater(), NLSOUND::CBackgroundSoundManager::loadSoundsFromPrimitives(), NL3D::CCameraCol::minimizeDistanceAgainstTri(), NL3D::CQuadGridClipClusterQTreeNode::noFrustumClip(), NL3D::NormalizeDsDt(), NL3D::NormalizeDsDtAsRGBA(), NL3D::CInstanceLighter::CPredPointLightToPoint::operator()(), NL3D::CVector3s::pack(), NL3D::CZoneLighter::processCalc(), NL3D::CShadowMap::processFades(), NL3D::CZoneLighter::processZonePointLightRT(), NLPACS::CPrimitiveWorldImage::reaction(), NLLIGO::IPrimitive::read(), ReadColor(), NL3D::CVegetableManager::render(), NL3D::CScene::render(), NL3D::CShadowMapManager::renderGenerate(), NL3D::CShadowMapManager::renderProject(), RenderTriangle(), NLMISC::CMouseSmoother::samplePos(), NL3D::CVisualCollisionManager::CStaticGrid::select(), NL3D::CPatchUVLocator::selectPatch(), NL3D::UWaterHeightMapManager::setBlendFactor(), NLSOUND::CSourceDSound::setGain(), NL3D::CParticleSystem::setGlobalValue(), NL3D::CLightingManager::setLightTransitionThreshold(), NL3D::CParticleSystem::setMaxDistLODBias(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setNormal(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setPos(), NL3D::CVisualCollisionManager::setSunContributionPower(), NL3D::CDriverGL::setupScissor(), NL3D::CPointLight::setupSpotAngle(), NL3D::CLandscape::setupStaticLight(), NL3D::CDriverGL::setupTextureEx(), NL3D::CDriverGL::setupViewport(), NL3D::CParticleSystem::setUserParam(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setUV(), NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex::setWeight(), NL3D::CVegetableManager::setWind(), NL3D::CPSLight::show(), NL3D::CParticleSystem::step(), NL3D::CSkeletonModel::traverseAnimDetail(), NL3D::CMeshMorpher::update(), NL3D::CAnimatedMaterial::update(), NLSOUND::CBackgroundSoundManager::updateBackgroundStatus(), NL3D::CPSRibbonBase::updateLOD(), NL3D::CParticleSystem::updateLODRatio(), NL3D::CMeshMorpher::updateSkinned(), NLSOUND::CSourceDSound::updateVolume(), and NL3D::CDriverGL::uploadTexture(). +
+
00116 { +00117 v = (v < min) ? min : v; +00118 v = (v > max) ? max : v; +00119 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T, class U>
T computeBilinear ( const T & v0,
const T & v1,
const T & v2,
const T & v3,
const U & s,
const U & t
)
+
+ + + + + +
+ + + +
+bilinear of 4 values v3 v2 +-----+ | | | | +-----+ v0 v1
+T ^ | | +---> S +
+Definition at line 55 of file algo.h. +
+References s, and t. +
+
00056 { +00057 T h0 = t * v3 + ((U) 1 - t) * v0; +00058 T h1 = t * v2 + ((U) 1 - t) * v1; +00059 return s * h1 + ((U) 1 - s) * h0; +00060 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool CopyMoveFile ( const char * dest,
const char * src,
bool copyFile,
bool failIfExists = false
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1601 of file path.cpp. +
+References nlwarning. +
+
01602 { +01603 if (!dest || !src) return false; +01604 if (!strlen(dest) || !strlen(src)) return false; +01605 #ifdef NL_OS_WINDOWS +01606 std::string dosdest = CPath::standardizeDosPath(dest); +01607 std::string dossrc = CPath::standardizeDosPath(src); +01608 +01609 return copyFile ? CopyFile(dossrc.c_str(), dosdest.c_str(), failIfExists) != FALSE +01610 : MoveFile(dossrc.c_str(), dosdest.c_str()) != FALSE; +01611 #else +01612 std::string sdest = CPath::standardizePath(dest,false); +01613 std::string ssrc = CPath::standardizePath(src,false); +01614 +01615 if(copyFile) +01616 { +01617 FILE *fp1 = fopen(ssrc.c_str(), "rb"); +01618 if (fp1 == NULL) +01619 { +01620 nlwarning ("PATH: CopyMoveFile error: can't fopen in read mode '%s'", ssrc.c_str()); +01621 return false; +01622 } +01623 FILE *fp2 = fopen(sdest.c_str(), "wb"); +01624 if (fp2 == NULL) +01625 { +01626 nlwarning ("PATH: CopyMoveFile error: can't fopen in read write mode '%s'", sdest.c_str()); +01627 return false; +01628 } +01629 static char buffer [1000]; +01630 int s; +01631 for(s = fread(buffer, 1, sizeof(buffer), fp1); s > 0 && (s = fread(buffer, 1, sizeof(buffer), fp1)) ; fwrite(buffer, 1, s, fp2)); +01632 fclose(fp1); +01633 fclose(fp2); +01634 } +01635 else +01636 { +01637 if (link (ssrc.c_str(), sdest.c_str()) == -1) +01638 { +01639 nlwarning ("PATH: CopyMoveFile error: can't link '%s' into '%s'", ssrc.c_str(), sdest.c_str()); +01640 return false; +01641 } +01642 +01643 if (unlink (ssrc.c_str()) == -1) +01644 { +01645 nlwarning ("PATH: CopyMoveFile error: can't unlink '%s'", ssrc.c_str()); +01646 return false; +01647 } +01648 } +01649 return true; +01650 #endif +01651 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::createDebug ( const char * logPath = NULL,
bool logInFile = true
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 900 of file debug.cpp. +
+References AssertLog, DebugLog, DefaultMemDisplayer, DefaultMsgBoxDisplayer, ErrorLog, fd, InfoLog, initDebug2(), IsDebuggerPresent, sd, TrapCrashInDebugger, and WarningLog. +
+Referenced by NLNET::CCallbackNetBase::CCallbackNetBase(), and NLMISC::CConfigFile::display(). +
+
00901 { +00902 NL_ALLOC_CONTEXT (_Debug) +00903 +00904 static bool alreadyCreateSharedAmongThreads = false; +00905 if ( !alreadyCreateSharedAmongThreads ) +00906 { +00907 // Debug Info for mutexes +00908 #ifdef MUTEX_DEBUG +00909 initAcquireTimeMap(); +00910 #endif +00911 +00912 #ifdef NL_OS_WINDOWS +00913 // if (!IsDebuggerPresent ()) +00914 { +00915 // Use an environment variable to share the value among the EXE and its child DLLs +00916 // (otherwise there would be one distinct bool by module, and the last +00917 // _set_se_translator would overwrite the previous ones) +00918 const char *SE_TRANSLATOR_IN_MAIN_MODULE = "NEL_SE_TRANS"; +00919 TCHAR envBuf [2]; +00920 if ( GetEnvironmentVariable( SE_TRANSLATOR_IN_MAIN_MODULE, envBuf, 2 ) == 0) +00921 { +00922 _set_se_translator(exceptionTranslator); +00923 SetEnvironmentVariable( SE_TRANSLATOR_IN_MAIN_MODULE, "1" ); +00924 } +00925 } +00926 #endif // NL_OS_WINDOWS +00927 +00928 ErrorLog = new CLog (CLog::LOG_ERROR); +00929 WarningLog = new CLog (CLog::LOG_WARNING); +00930 InfoLog = new CLog (CLog::LOG_INFO); +00931 DebugLog = new CLog (CLog::LOG_DEBUG); +00932 AssertLog = new CLog (CLog::LOG_ASSERT); +00933 +00934 sd = new CStdDisplayer ("DEFAULT_SD"); +00935 +00936 #ifdef NL_OS_WINDOWS +00937 if (TrapCrashInDebugger || !IsDebuggerPresent ()) +00938 { +00939 DefaultMsgBoxDisplayer = new CMsgBoxDisplayer ("DEFAULT_MBD"); +00940 } +00941 #endif +00942 +00943 #if LOG_IN_FILE +00944 if (logInFile) +00945 { +00946 string fn; +00947 if (logPath != NULL) +00948 { +00949 fn += logPath; +00950 } +00951 else +00952 { +00953 // we want the log.log to be in the current directory +00954 // char tmpPath[1024]; +00955 // fn += getcwd(tmpPath, 1024); +00956 // fn += "/"; +00957 } +00958 fn += "log.log"; +00959 fd = new CFileDisplayer (fn, false, "DEFAULT_FD"); +00960 } +00961 #endif // LOG_IN_FILE +00962 DefaultMemDisplayer = new CMemDisplayer ("DEFAULT_MD"); +00963 +00964 initDebug2(logInFile); +00965 +00966 alreadyCreateSharedAmongThreads = true; +00967 } +00968 } +

+

+ + + + +
+ + + + + + + + + + +
float degToRad ( float deg ) [inline]
+
+ + + + + +
+ + + +
+Converts from degrees to radians +
+Definition at line 170 of file common.h. +
+References Pi. +
+Referenced by NLSOUND::CSourceAL::getCone(). +
+
00171 { +00172 return deg * (float)Pi / 180.0f; +00173 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::DetectMMX ( void ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 34 of file cpu_info.cpp. +
+References uint32. +
+
00035 { +00036 #ifdef NL_OS_WINDOWS +00037 if (!CCpuInfo___::hasCPUID()) return false; // cpuid not supported ... +00038 +00039 uint32 result = 0; +00040 __asm +00041 { +00042 mov eax,1 +00043 cpuid +00044 test edx,0x800000 // bit 23 = MMX instruction set +00045 je noMMX +00046 mov result, 1 +00047 noMMX: +00048 } +00049 +00050 return result == 1; +00051 +00052 // printf("mmx detected\n"); +00053 +00054 #else +00055 return false; +00056 #endif +00057 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::DetectSSE ( void ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 60 of file cpu_info.cpp. +
+References uint32. +
+
00061 { +00062 #ifdef NL_OS_WINDOWS +00063 if (!CCpuInfo___::hasCPUID()) return false; // cpuid not supported ... +00064 +00065 uint32 result = 0; +00066 __asm +00067 { +00068 mov eax, 1 // request for feature flags +00069 cpuid +00070 test EDX, 002000000h // bit 25 in feature flags equal to 1 +00071 je noSSE +00072 mov result, 1 // sse detected +00073 noSSE: +00074 } +00075 +00076 +00077 if (result) +00078 { +00079 // check OS support for SSE +00080 try +00081 { +00082 __asm +00083 { +00084 xorps xmm0, xmm0 // Streaming SIMD Extension +00085 } +00086 } +00087 catch(...) +00088 { +00089 return false; +00090 } +00091 +00092 // printf("sse detected\n"); +00093 +00094 return true; +00095 } +00096 else +00097 { +00098 return false; +00099 } +00100 #else +00101 return false; +00102 #endif +00103 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::displayBitStream ( const CBitMemStream & msg,
sint beginbitpos,
sint endbitpos,
NLMISC::CLog * log = NLMISC::DebugLog
)
+
+ + + + + +
+ + + +
+Display a part of a bitmemstream. +
+ +
+Definition at line 652 of file bit_mem_stream.cpp. +
+References NLMISC::CMemStream::buffer(), displayByteBits(), nlinfo, sint, and uint8. +
+Referenced by NLMISC::CBitMemStream::displayLastBits(). +
+
00653 { +00654 sint beginpos = beginbitpos/8; +00655 sint endpos = endbitpos/8; +00656 nlinfo( "BMS: beginpos %d endpos %d beginbitpos %d endbitpos %d", beginpos, endpos, beginbitpos, endbitpos ); +00657 displayByteBits( *(msg.buffer()+beginpos), 8, 8-(beginbitpos-beginpos*8), true, log ); +00658 const uint8 *p; +00659 for ( p=msg.buffer()+beginpos+1; p<msg.buffer()+endpos-1; ++p ) +00660 { +00661 displayByteBits( *p, 8, 0, false, log ); +00662 } +00663 if ( endpos > beginpos ) +00664 { +00665 displayByteBits( *(msg.buffer()+endpos), 8, 0, false, log ); +00666 } +00667 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::displayByteBits ( uint8 b,
uint nbits,
sint beginpos,
bool displayBegin,
NLMISC::CLog * log
)
+
+ + + + + +
+ + + +
+Display the bits (with 0 and 1) composing a byte (from right to left). +
+ +
+Definition at line 856 of file common.cpp. +
+References NLMISC::CLog::displayRawNL(), sint, uint, and uint8. +
+Referenced by displayBitStream(). +
+
00857 { +00858 string s1, s2; +00859 sint i; +00860 for ( i=nbits-1; i!=-1; --i ) +00861 { +00862 s1 += ( (b >> i) & 1 ) ? '1' : '0'; +00863 } +00864 log->displayRawNL( "%s", s1.c_str() ); +00865 if ( displayBegin ) +00866 { +00867 for ( i=nbits; i>beginpos+1; --i ) +00868 { +00869 s2 += " "; +00870 } +00871 s2 += "^"; +00872 log->displayRawNL( "%s beginpos=%u", s2.c_str(), beginpos ); +00873 } +00874 } +

+

+ + + + +
+ + + + + + + + + + +
void displayCallStack ( CLog * log ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 307 of file mem_displayer.cpp. +
+References NLMISC::CLog::displayNL(). +
+Referenced by NLMISC::CMemDisplayer::write(). +
+
00308 { +00309 log->displayNL ("no call stack info available"); +00310 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::displayDwordBits ( uint32 b,
uint nbits,
sint beginpos,
bool displayBegin,
NLMISC::CLog * log
)
+
+ + + + + +
+ + + +
+Display the bits (with 0 and 1) composing a number (uint32) (from right to left). +
+ +
+Definition at line 882 of file common.cpp. +
+References NLMISC::CLog::displayRawNL(), sint, uint, and uint32. +
+
00883 { +00884 string s1, s2; +00885 sint i; +00886 for ( i=nbits-1; i!=-1; --i ) +00887 { +00888 s1 += ( (b >> i) & 1 ) ? '1' : '0'; +00889 } +00890 log->displayRawNL( "%s", s1.c_str() ); +00891 if ( displayBegin ) +00892 { +00893 for ( i=nbits; i>beginpos+1; --i ) +00894 { +00895 s2 += " "; +00896 } +00897 s2 += "^"; +00898 log->displayRawNL( "%s beginpos=%u", s2.c_str(), beginpos ); +00899 } +00900 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::drawFullLine ( float x0,
float y0,
float x1,
float y1,
std::vector< std::pair< sint, sint > > & result
)
+
+ + + + + +
+ + + +
+Select all points crossed by the line [(x0,y0) ; (x1,y1)] Not the same than brensenham +
+Definition at line 142 of file algo.cpp. +
+References sint. +
+Referenced by draw2dLine(). +
+
00143 { +00144 result.clear (); +00145 // x0 must be < x1 +00146 float dx = (float) fabs (x0-x1); +00147 float dy = (float) fabs (y0-y1); +00148 if ((dx == 0) && (dy == 0)) +00149 result.push_back (pair<sint, sint> ((sint)floor (x0), (sint)floor (y0))); +00150 else if (dx > dy) +00151 { +00152 if (x0 > x1) +00153 { +00154 // Xchg 0 and 1 +00155 float temp = x0; +00156 x0 = x1; +00157 x1 = temp; +00158 temp = y0; +00159 y0 = y1; +00160 y1 = temp; +00161 } +00162 +00163 float deltaX = x1 - x0; +00164 const float deltaY = (y1-y0)/deltaX; +00165 +00166 // Current integer pixel +00167 sint currentX = (sint)floor (x0); +00168 sint currentY = (sint)floor (y0); +00169 +00170 while (deltaX >= 0) +00171 { +00172 // Next point +00173 sint previousY = currentY; +00174 +00175 // Next y0 +00176 if (deltaX > 1) +00177 y0 += deltaY; +00178 else +00179 y0 += deltaX * deltaY; +00180 +00181 deltaX -= 1; +00182 +00183 currentY = (sint)y0; +00184 +00185 // Add point +00186 if (currentY<=previousY) +00187 { +00188 do +00189 { +00190 result.push_back (pair<sint, sint> (currentX, previousY)); +00191 previousY--; +00192 } +00193 while (currentY<=previousY); +00194 } +00195 else +00196 { +00197 do +00198 { +00199 result.push_back (pair<sint, sint> (currentX, previousY)); +00200 previousY++; +00201 } +00202 while (currentY>=previousY); +00203 } +00204 +00205 // Next X +00206 currentX++; +00207 } +00208 } +00209 else +00210 { +00211 if (y0 > y1) +00212 { +00213 // Xchg 0 and 1 +00214 float temp = y0; +00215 y0 = y1; +00216 y1 = temp; +00217 temp = x0; +00218 x0 = x1; +00219 x1 = temp; +00220 } +00221 +00222 float deltaY = y1 - y0; +00223 const float deltaX = (x1-x0)/deltaY; +00224 +00225 // Current integer pixel +00226 sint currentY = (sint)floor (y0); +00227 sint currentX = (sint)floor (x0); +00228 +00229 while (deltaY >= 0) +00230 { +00231 // Next point +00232 sint previousX = currentX; +00233 +00234 // Next x0 +00235 if (deltaY > 1) +00236 x0 += deltaX; +00237 else +00238 x0 += deltaY * deltaX; +00239 +00240 deltaY -= 1; +00241 +00242 currentX = (sint)x0; +00243 +00244 // Add point +00245 if (currentX<=previousX) +00246 { +00247 do +00248 { +00249 result.push_back (pair<sint, sint> (previousX, currentY)); +00250 previousX--; +00251 } +00252 while (currentX<=previousX); +00253 } +00254 else +00255 { +00256 do +00257 { +00258 result.push_back (pair<sint, sint> (previousX, currentY)); +00259 previousX++; +00260 } +00261 while (currentX>=previousX); +00262 } +00263 +00264 // Next Y +00265 currentY++; +00266 } +00267 } +00268 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void drawLine ( float x0,
float y0,
float x1,
float y1,
std::vector< std::pair< sint, sint > > & result
)
+
+ + + + + +
+ + + +
+Select points on the line [(x0,y0) ; (x1,y1)]
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void drawLine ( float x0,
float y0,
float x1,
float y1,
vector< pair< sint, sint > > & result
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 272 of file algo.cpp. +
+References sint. +
+
00273 { +00274 float dx = (float)(floor(x1+0.5) - floor(x0+0.5)); +00275 float dy = (float)(floor(y1+0.5) - floor(y0+0.5)); +00276 +00277 float rdx = x1-x0; +00278 float rdy = y1-y0; +00279 +00280 sint d = (sint)std::max(fabs(dx), fabs(dy)); +00281 float maxd = (float)(std::max(fabs(rdx), fabs(rdy))); +00282 +00283 rdx /= maxd; +00284 rdy /= maxd; +00285 +00286 for (; d>=0; --d) +00287 { +00288 result.push_back(make_pair<sint,sint>((sint)floor(x0+0.5), (sint)floor(y0+0.5))); +00289 +00290 x0 += rdx; +00291 y0 += rdy; +00292 } +00293 } +

+

+ + + + +
+ + + + + + + + + + +
void enterBreakpoint ( const char * message )
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::explode ( const std::string & src,
const std::string & sep,
std::vector< std::string > & res,
bool skipEmpty = false
)
+
+ + + + + +
+ + + +
+Explode a string into a vector of string with *sep* as separator. If sep can be more than 1 char, in this case, we find the entire sep to separator (it s not a set of possible separator)
+
Parameters:
+ + +
skipEmpty if true, we don't put in the res vector empty string
+
+ +
+Definition at line 821 of file common.cpp. +
+References res, s, and src. +
+Referenced by STRING_MANAGER::preparePhraseFile(), and STRING_MANAGER::prepareStringFile(). +
+
00822 { +00823 string::size_type oldpos = 0, pos; +00824 +00825 res.clear (); +00826 +00827 do +00828 { +00829 pos = src.find (sep, oldpos); +00830 string s; +00831 if(pos == string::npos) +00832 s = src.substr (oldpos); +00833 else +00834 s = src.substr (oldpos, (pos-oldpos)); +00835 +00836 if (!skipEmpty || !s.empty()) +00837 res.push_back (s); +00838 +00839 oldpos = pos+1; +00840 } +00841 while(pos != string::npos); +00842 +00843 // debug +00844 /* nlinfo ("Exploded '%s', with '%s', %d res", src.c_str(), sep.c_str(), res.size()); +00845 for (uint i = 0; i < res.size(); i++) +00846 { +00847 nlinfo (" > '%s'", res[i].c_str()); +00848 } +00849 */ +00850 } +

+

+ + + + +
+ + + + + + + + + + +
void fastClamp8 ( sint & v ) [inline, static]
+
+ + + + + +
+ + + +
+Clamp a sint in 0..255. Avoid cond jump. +
+Definition at line 122 of file algo.h. +
+References clamp(), sint, and v. +
+
00123 { +00124 #ifdef NL_OS_WINDOWS +00125 // clamp v in 0..255 (no cond jmp) +00126 __asm +00127 { +00128 mov esi, v +00129 mov eax, [esi] +00130 mov ebx, eax +00131 // clamp to 0. +00132 add eax, 0x80000000 +00133 sbb ecx, ecx +00134 not ecx +00135 and ebx, ecx +00136 // clamp to 255. +00137 add eax, 0x7FFFFF00 +00138 sbb ecx, ecx +00139 or ebx, ecx +00140 and ebx, 255 +00141 // store +00142 mov [esi], ebx +00143 } +00144 #else +00145 clamp(v, 0, 255); +00146 #endif +00147 } +

+

+ + + + +
+ + + + + + + + + +
memcpyPtr findBestmemcpy ( ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 227 of file fast_mem.cpp. +
+References memcpyPtr. +
+
00228 { +00229 #ifdef NL_OS_WINDOWS +00230 if (CSystemInfo::hasSSE ()) +00231 return CFastMem::memcpySSE; +00232 else +00233 return ::memcpy; +00234 #else // NL_OS_WINDOWS +00235 return ::memcpy; +00236 #endif // NL_OS_WINDOWS +00237 } +

+

+ + + + +
+ + + + + + + + + + +
void fprintf_int ( uint value )
+
+ + + + + +
+ + + +
+ +
+Definition at line 1368 of file misc/heap_allocator.cpp. +
+References uint, and value. +
+
01369 { +01370 +01371 } +

+

+ + + + +
+ + + + + + + + + + +
float frand ( float mod ) [inline]
+
+ + + + + +
+ + + +
+Return a float random inside the interval [0,mod] +
+Definition at line 84 of file common.h. +
+References r. +
+Referenced by NLMISC::CRandomGrid3D::CRandomGrid3D(), and NL3D::CMeshVPWindTree::initInstance(). +
+
00085 { +00086 double r = (double) rand(); +00087 r/= (double) RAND_MAX; +00088 return (float)(r * mod); +00089 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 NLMISC::fromHumanReadable ( const std::string & str )
+
+ + + + + +
+ + + +
+Get a bytes or time in string format and convert it in seconds or bytes. +
+ +
+Definition at line 499 of file common.cpp. +
+References uint32. +
+
00500 { +00501 if (str.size() == 0) +00502 return 0; +00503 +00504 uint32 val = atoi (str.c_str()); +00505 +00506 switch (str[str.size()-1]) +00507 { +00508 case 's': return val; // second +00509 case 'n': return val*60; // minutes (mn) +00510 case 'h': return val*60*60; // hour +00511 case 'd': return val*60*60*24; // day +00512 case 'b': // bytes +00513 switch (str[str.size()-2]) +00514 { +00515 case 'k': return val*1024; +00516 case 'm': return val*1024*1024; +00517 case 'g': return val*1024*1024*1024; +00518 default : return val; +00519 } +00520 default: return val; +00521 } +00522 return 0; +00523 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
std::string & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 214 of file string_common.h. +
+
00214 { val = str; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
bool & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 213 of file string_common.h. +
+References fromString(), uint32, and v. +
+
00213 { uint32 v; fromString(str, v); val = (v==1); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
double & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 212 of file string_common.h. +
+
00212 { sscanf(str.c_str(), "%lf", &val); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
float & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 211 of file string_common.h. +
+
00211 { sscanf(str.c_str(), "%f", &val); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
sint64 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 210 of file string_common.h. +
+References NL_I64, and sint64. +
+
00210 { sscanf(str.c_str(), "%"NL_I64"d", &val); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
uint64 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 209 of file string_common.h. +
+References NL_I64, and uint64. +
+
00209 { sscanf(str.c_str(), "%"NL_I64"u", &val); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
sint16 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 208 of file string_common.h. +
+References fromString(), sint16, uint32, and v. +
+
00208 { uint32 v; fromString(str, v); val = (sint16)v; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
uint16 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 207 of file string_common.h. +
+References fromString(), uint16, uint32, and v. +
+
00207 { uint32 v; fromString(str, v); val = (uint16)v; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
sint8 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 206 of file string_common.h. +
+References fromString(), sint32, sint8, and v. +
+
00206 { sint32 v; fromString(str, v); val = (sint8)v; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
uint8 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 205 of file string_common.h. +
+References fromString(), uint32, uint8, and v. +
+
00205 { uint32 v; fromString(str, v); val = (uint8)v; } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
sint32 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 204 of file string_common.h. +
+References sint32. +
+
00204 { sscanf(str.c_str(), "%d", &val); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void fromString ( const std::string & str,
uint32 & val
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 203 of file string_common.h. +
+References uint32. +
+Referenced by NLMISC::CVariable< std::string >::execute(), NLMISC::CVariable< std::string >::fromString(), NLMISC::CVariablePtr< T >::fromString(), and fromString(). +
+
00203 { sscanf(str.c_str(), "%u", &val); } +

+

+ + + + +
+ + + + + + + + + + +
sint fsgn ( double f ) [inline]
+
+ + + + + +
+ + + +
+Return -1 if f<0, 0 if f==0, 1 if f>1 +
+Definition at line 94 of file common.h. +
+References sint. +
+Referenced by NLPACS::CEdgeCollide::testPointMove(). +
+
00095 { +00096 if(f<0) +00097 return -1; +00098 else if(f>0) +00099 return 1; +00100 else +00101 return 0; +00102 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::getCallStackAndLog ( std::string & result,
sint skipNFirst = 0
)
+
+ + + + + +
+ + + +
+Get the call stack and set it with result. +
+ +
+Definition at line 836 of file debug.cpp. +
+References CrashCallback, DefaultMemDisplayer, sint, and NLMISC::CMemDisplayer::write(). +
+Referenced by NLMISC::CLog::displayRawString(), and NLMISC::CLog::displayString(). +
+
00837 { +00838 #ifdef NL_OS_WINDOWS +00839 try +00840 { +00841 WORKAROUND_VCPP_SYNCHRONOUS_EXCEPTION // force to install a exception frame +00842 +00843 DWORD array[1]; +00844 array[0] = skipNFirst; +00845 RaiseException (0xACE0ACE, 0, 1, array); +00846 } +00847 catch (EDebug &e) +00848 { +00849 result += e.what(); +00850 } +00851 #else +00852 +00853 // there s no stack on GNU/Linux, only get the log without filters +00854 +00855 result += "No callstack available\n"; +00856 result += "-------------------------------\n"; +00857 result += "\n"; +00858 if(DefaultMemDisplayer) +00859 { +00860 result += "Log with no filter:\n"; +00861 result += "-------------------------------\n"; +00862 DefaultMemDisplayer->write (result); +00863 } +00864 else +00865 { +00866 result += "No log\n"; +00867 } +00868 result += "-------------------------------\n"; +00869 +00870 // add specific information about the application +00871 if(CrashCallback) +00872 { +00873 result += "User Crash Callback:\n"; +00874 result += "-------------------------------\n"; +00875 static bool looping = false; +00876 if(looping) +00877 { +00878 result += "******* WARNING: crashed in the user crash callback *******\n"; +00879 looping = false; +00880 } +00881 else +00882 { +00883 looping = true; +00884 result += CrashCallback(); +00885 looping = false; +00886 } +00887 result += "-------------------------------\n"; +00888 } +00889 +00890 #endif +00891 } +

+

+ + + + +
+ + + + + + + + + + +
string getname ( dirent * de )
+
+ + + + + +
+ + + +
+ +
+Definition at line 678 of file path.cpp. +
+
00679 { +00680 nlassert (de != NULL); +00681 #ifdef NL_OS_WINDOWS +00682 return de->cFileName; +00683 #else +00684 return de->d_name; +00685 #endif // NL_OS_WINDOWS +00686 } +

+

+ + + + +
+ + + + + + + + + + +
uint NLMISC::getPowerOf2 ( uint v )
+
+ + + + + +
+ + + +
+Return the power of 2 of v. Example: getPowerOf2(8) is 3 getPowerOf2(5) is 3 +
+Definition at line 358 of file common.cpp. +
+References res, uint, and v. +
+Referenced by NL3D::CStaticQuadGrid< T >::build(), NL3D::CLodCharacterTmpBitmap::build(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CZoneLighter::buildZoneInformation(), NL3D::CLandscapeCollisionGrid::CLandscapeCollisionGrid(), NL3D::CPatch::compile(), NL3D::CVisualCollisionManager::CStaticGrid::create(), NL3D::CQuadGrid< T >::create(), NLPACS::CFaceGrid::create(), NL3D::CDriverGL::forceTextureResize(), NL3D::CLandscapeFaceVectorManager::getBlockIdFromNumTri(), NL3D::CTextureFar::getFreeListId(), NL3D::CTextureDLM::getTypeForSize(), NL3D::CNoise3d::init(), NL3D::SCloudTextureClamp::init(), NL3D::SCloudTexture3D::init(), NL3D::CCloud::init(), and NLMISC::CBitmap::readDDS(). +
+
00359 { +00360 uint res=1; +00361 uint ret=0; +00362 while(res<v) +00363 { +00364 ret++; +00365 res<<=1; +00366 } +00367 +00368 return ret; +00369 } +

+

+ + + + +
+ + + + + + + + + +
uint NLMISC::getThreadId ( )
+
+ + + + + +
+ + + +
+Returns Process Id (note: on Linux, Process Id is the same as the Thread Id) Returns Thread Id (note: on Linux, Process Id is the same as the Thread Id). +
+ +
+Definition at line 93 of file common.cpp. +
+References uint. +
+Referenced by NLNET::CUnifiedNetwork::addService(), NLNET::CCallbackNetBase::CCallbackNetBase(), NLNET::CUnifiedNetwork::connect(), NLMISC::CLog::displayString(), NLNET::CUnifiedNetwork::getNetBase(), NLNET::CUnifiedNetwork::init(), NLNET::initSignal(), NLNET::CUnifiedNetwork::release(), NLNET::CUnifiedNetwork::send(), NLNET::CUnifiedNetwork::sendAll(), NLNET::sigHandler(), and NLNET::CUnifiedNetwork::update(). +
+
00094 { +00095 #ifdef NL_OS_WINDOWS +00096 return GetCurrentThreadId(); +00097 #elif defined NL_OS_UNIX +00098 return getpid(); +00099 #endif +00100 +00101 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
float HLSValue ( float h,
float v1,
float v2
) [static]
+
+ + + + + +
+ + + +
+Used by buildFromHLS. +
+ +
+Definition at line 658 of file rgba.cpp. +
+Referenced by NLMISC::CRGBA::buildFromHLS(). +
+
00659 { +00660 /* get hue in the [0, 360] interval */ +00661 // h -= 360.f * ::floorf(h / 360.f); +00662 +00663 if (h > 360.f) h -= 360.f; +00664 else if (h < 0) h += 360.f; +00665 +00666 if (h < 60.f) +00667 { +00668 return v1 + (v2 - v1) * h / 60.f; +00669 } +00670 else if (h < 180.f) +00671 { +00672 return v2; +00673 } +00674 else if (h < 240.f) +00675 { +00676 return v1 + (v2 - v1) * (240.f - h) / 60.f; +00677 } +00678 else +00679 { +00680 return v1; +00681 } +00682 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 humanReadableToBytes ( const std::string & str )
+
+ + + + + +
+ + + +
+Convert a human readable into a bytes, for example "102kb" -> 105123. +
+
+

+ + + + +
+ + + + + + + + + + +
uint32 humanReadableToBytes ( const string & str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 422 of file common.cpp. +
+References res, and uint32. +
+Referenced by NLMISC_COMMAND(), and NLNET::updateAdmin(). +
+
00423 { +00424 uint32 res; +00425 +00426 if(str.empty()) +00427 return 0; +00428 +00429 // not a number +00430 if(str[0]<'0' || str[0]>'9') +00431 return 0; +00432 +00433 res = atoi (str.c_str()); +00434 +00435 if(str[str.size()-1] == 'b') +00436 { +00437 if (str.size()<3) +00438 return res; +00439 +00440 // there s no break and it s **normal** +00441 switch (str[str.size()-2]) +00442 { +00443 case 'g': res *= 1024; +00444 case 'm': res *= 1024; +00445 case 'k': res *= 1024; +00446 default: ; +00447 } +00448 } +00449 +00450 return res; +00451 } +

+

+ + + + +
+ + + + + + + + + + +
void initDebug2 ( bool logInFile )
+
+ + + + + +
+ + + +
+ +
+Definition at line 154 of file debug.cpp. +
+References NLMISC::CLog::addDisplayer(), AssertLog, DebugLog, DefaultMemDisplayer, DefaultMsgBoxDisplayer, ErrorLog, fd, InfoLog, nlwarning, sd, and WarningLog. +
+Referenced by createDebug(). +
+
00155 { +00156 static bool alreadyInit = false; +00157 +00158 if (!alreadyInit) +00159 { +00160 #if DEFAULT_DISPLAYER +00161 +00162 // put the standard displayer everywhere +00163 +00164 #ifdef NL_DEBUG +00165 DebugLog->addDisplayer (sd); +00166 #endif // NL_DEBUG +00167 InfoLog->addDisplayer (sd); +00168 WarningLog->addDisplayer (sd); +00169 AssertLog->addDisplayer (sd); +00170 ErrorLog->addDisplayer (sd); +00171 +00172 // put the memory displayer everywhere +00173 +00174 // use the memory displayer and bypass all filter (even for the debug mode) +00175 DebugLog->addDisplayer (DefaultMemDisplayer, true); +00176 InfoLog->addDisplayer (DefaultMemDisplayer, true); +00177 WarningLog->addDisplayer (DefaultMemDisplayer, true); +00178 AssertLog->addDisplayer (DefaultMemDisplayer, true); +00179 ErrorLog->addDisplayer (DefaultMemDisplayer, true); +00180 +00181 // put the file displayer only if wanted +00182 +00183 #if LOG_IN_FILE +00184 if (logInFile) +00185 { +00186 #ifdef NL_DEBUG +00187 DebugLog->addDisplayer (fd); +00188 #endif // NL_DEBUG +00189 InfoLog->addDisplayer (fd); +00190 WarningLog->addDisplayer (fd); +00191 AssertLog->addDisplayer (fd); +00192 ErrorLog->addDisplayer (fd); +00193 } +00194 #endif // LOG_IN_FILE +00195 +00196 // put the message box only in release for error +00197 +00198 if (DefaultMsgBoxDisplayer) +00199 { +00200 AssertLog->addDisplayer (DefaultMsgBoxDisplayer); +00201 ErrorLog->addDisplayer (DefaultMsgBoxDisplayer); +00202 } +00203 +00204 #endif // DEFAULT_DISPLAYER +00205 alreadyInit = true; +00206 } +00207 else +00208 { +00209 nlwarning ("NLMISC::initDebug2() already called"); +00210 } +00211 } +

+

+ + + + +
+ + + + + + + + + + +
bool isdirectory ( dirent * de )
+
+ + + + + +
+ + + +
+ +
+Definition at line 649 of file path.cpp. +
+
00650 { +00651 nlassert (de != NULL); +00652 #ifdef NL_OS_WINDOWS +00653 return ((de->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) && ((de->dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == 0); +00654 #else +00655 //nlinfo ("isdirectory filename %s -> 0x%08x", de->d_name, de->d_type); +00656 // we can't use "de->d_type & DT_DIR" because it s always NULL on libc2.1 +00657 //return (de->d_type & DT_DIR) != 0; +00658 +00659 return CFile::isDirectory (BasePathgetPathContent + de->d_name); +00660 +00661 #endif // NL_OS_WINDOWS +00662 } +

+

+ + + + +
+ + + + + + + + + + +
bool isfile ( dirent * de )
+
+ + + + + +
+ + + +
+ +
+Definition at line 664 of file path.cpp. +
+
00665 { +00666 nlassert (de != NULL); +00667 #ifdef NL_OS_WINDOWS +00668 return ((de->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) && ((de->dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) == 0); +00669 #else +00670 // we can't use "de->d_type & DT_DIR" because it s always NULL on libc2.1 +00671 //return (de->d_type & DT_DIR) == 0; +00672 +00673 return !CFile::isDirectory (BasePathgetPathContent + de->d_name); +00674 +00675 #endif // NL_OS_WINDOWS +00676 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::isPowerOf2 ( sint32 v )
+
+ + + + + +
+ + + +
+Return true if the value is a power of 2. +
+Definition at line 371 of file common.cpp. +
+References sint32, and v. +
+Referenced by NL3D::CShadowMapManager::allocateTexture(), NLMISC::CBitmap::buildMipMaps(), NL3D::CZoneLighter::buildZoneInformation(), NL3D::CLandscapeCollisionGrid::CLandscapeCollisionGrid(), NL3D::CVisualCollisionManager::CStaticGrid::create(), NL3D::CTextureFar::getFreeListId(), NL3D::CTextureFar::getUpperSize(), NL3D::CTessFacePriorityList::init(), and NL3D::CShadowMapManager::renderGenerate(). +
+
00372 { +00373 while(v) +00374 { +00375 if(v&1) +00376 { +00377 v>>=1; +00378 if(v) +00379 return false; +00380 } +00381 else +00382 v>>=1; +00383 } +00384 +00385 return true; +00386 } +

+

+ + + + +
+ + + + + + + + + + +
double isValidDouble ( double v ) [inline]
+
+ + + + + +
+ + + +
+Return true if double is a valid value (not inf nor nan) +
+Definition at line 186 of file common.h. +
+References v. +
+Referenced by NL3D::CLoadBalancingGroup::computeRatioAndSmooth(). +
+
00187 { +00188 #ifdef NL_OS_WINDOWS +00189 return _finite(v) && !_isnan(v); +00190 #else +00191 return !isnan(v) && !isinf(v); +00192 #endif +00193 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::itoaInt64 ( sint64 number,
char * str,
sint64 base = 10
)
+
+ + + + + +
+ + + +
+Convert an sint64 into a string (same as itoa() function but for 64 bits intergers). +
+ +
+Definition at line 308 of file common.cpp. +
+References num, sint, sint64, and x. +
+
00309 { +00310 str[0] = '\0'; +00311 char b[256]; +00312 if(!number) +00313 { +00314 str[0] = '0'; +00315 str[1] = '\0'; +00316 return; +00317 } +00318 memset(b,'\0',255); +00319 memset(b,'0',64); +00320 sint n; +00321 sint64 x = number; +00322 if (x < 0) x = -x; +00323 char baseTable[] = "0123456789abcdefghijklmnopqrstuvwyz"; +00324 for(n = 0; n < 64; n ++) +00325 { +00326 sint num = (sint)(x % base); +00327 b[64 - n] = baseTable[num]; +00328 if(!x) +00329 { +00330 int k; +00331 int j = 0; +00332 +00333 if (number < 0) +00334 { +00335 str[j++] = '-'; +00336 } +00337 +00338 for(k = 64 - n + 1; k <= 64; k++) +00339 { +00340 str[j ++] = b[k]; +00341 } +00342 str[j] = '\0'; +00343 break; +00344 } +00345 x /= base; +00346 } +00347 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CStringConversion<TKey> KeyConversion ( stringTable ,
sizeof(stringTable)/sizeof(stringTable[0]) ,
KeyCount
) [static]
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventKey::getKeyFromString(), and NLMISC::CEventKey::getStringFromKey().
+

+ + + + +
+ + + + + + + + + + +
bool NLMISC::killProgram ( uint32 pid )
+
+ + + + + +
+ + + +
+This function kill a program using his pid (on unix, it uses the kill() POSIX function). +
+ +
+Definition at line 677 of file common.cpp. +
+References nlwarning, res, and uint32. +
+Referenced by NLMISC_COMMAND(). +
+
00678 { +00679 #ifdef NL_OS_UNIX +00680 int res = kill(pid, SIGKILL); +00681 if(res == -1) +00682 { +00683 char *err = strerror (errno); +00684 nlwarning("Failed to kill '%d' err %d: '%s'", pid, errno, err); +00685 } +00686 return res == 0; +00687 /*#elif defined(NL_OS_WINDOWS) +00688 // it doesn't work because pid != handle and i don't know how to kill a pid or know the real handle of another service (not -1) +00689 int res = TerminateProcess((HANDLE)pid, 888); +00690 LPVOID lpMsgBuf; +00691 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); +00692 nlwarning("Failed to kill '%d' err %d: '%s'", pid, GetLastError (), lpMsgBuf); +00693 LocalFree(lpMsgBuf); +00694 return res != 0; +00695 */ +00696 #else +00697 nlwarning("kill not implemented on this OS"); +00698 return false; +00699 #endif +00700 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::launchProgram ( const std::string & programName,
const std::string & arguments
)
+
+ + + + + +
+ + + +
+This function execute a program in the background and returns instantly (used for example to launch services in AES). The program will be launch in the current directory +
+Definition at line 702 of file common.cpp. +
+References nlassert, nldebug, nlwarning, res, uint, and uint32. +
+Referenced by NLMISC_COMMAND(). +
+
00703 { +00704 +00705 #ifdef NL_OS_WINDOWS +00706 STARTUPINFO si; +00707 PROCESS_INFORMATION pi; +00708 +00709 memset(&si, 0, sizeof(si)); +00710 memset(&pi, 0, sizeof(pi)); +00711 +00712 si.cb = sizeof(si); +00713 +00714 /* SECURITY_ATTRIBUTES sa; +00715 sa.nLength = sizeof (sa); +00716 sa.lpSecurityDescriptor = NULL; +00717 sa.bInheritHandle = FALSE; +00718 +00719 STARTUPINFO si; +00720 si.cb = sizeof (si); +00721 si.lpReserved = NULL; +00722 si.lpDesktop = NULL; +00723 si.lpTitle = NULL; +00724 si.dwFlags = STARTF_USESHOWWINDOW; +00725 si.cbReserved2 = 0; +00726 si.wShowWindow = SW_MINIMIZE; +00727 si.lpReserved2 = NULL; +00728 +00729 PROCESS_INFORMATION pi; +00730 */ +00731 string arg = " " + arguments; +00732 BOOL res = CreateProcess(programName.c_str(), (char*)arg.c_str(), 0, 0, FALSE, CREATE_DEFAULT_ERROR_MODE | CREATE_NO_WINDOW, 0, 0, &si, &pi); +00733 +00734 if (res) +00735 { +00736 nldebug("LAUNCH: Successful launch '%s' with arg '%s'", programName.c_str(), arguments.c_str()); +00737 return true; +00738 } +00739 else +00740 { +00741 LPVOID lpMsgBuf; +00742 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); +00743 nlwarning("LAUNCH: Failed launched '%s' with arg '%s' err %d: '%s'", programName.c_str(), arguments.c_str(), GetLastError (), lpMsgBuf); +00744 LocalFree(lpMsgBuf); +00745 } +00746 +00747 #elif defined(NL_OS_UNIX) +00748 +00749 static bool firstLaunchProgram = true; +00750 if (firstLaunchProgram) +00751 { +00752 // The aim of this is to avoid defunct process. +00753 // +00754 // From "man signal": +00755 //------ +00756 // According to POSIX (3.3.1.3) it is unspecified what happens when SIGCHLD is set to SIG_IGN. Here +00757 // the BSD and SYSV behaviours differ, causing BSD software that sets the action for SIGCHLD to +00758 // SIG_IGN to fail on Linux. +00759 //------ +00760 // +00761 // But it works fine on my GNU/Linux so I do this because it's easier :) and I don't know exactly +00762 // what to do to be portable. +00763 signal(SIGCHLD,SIG_IGN); +00764 +00765 firstLaunchProgram = false; +00766 } +00767 +00768 int status = vfork (); +00769 if (status == -1) +00770 { +00771 char *err = strerror (errno); +00772 nlwarning("LAUNCH: Failed launched '%s' with arg '%s' err %d: '%s'", programName.c_str(), arguments.c_str(), errno, err); +00773 } +00774 else if (status == 0) +00775 { +00776 // convert one arg into several args +00777 vector<string> args; +00778 char *argv[15]; +00779 +00780 uint32 pos1 = 0, pos2 = 0; +00781 +00782 do +00783 { +00784 pos1 = arguments.find_first_not_of (" ", pos2); +00785 if (pos1 == string::npos) break; +00786 pos2 = arguments.find_first_of (" ", pos1); +00787 args.push_back (arguments.substr (pos1, pos2-pos1)); +00788 } +00789 while (pos2 != string::npos); +00790 +00791 nlassert (args.size() < 15); +00792 +00793 uint i = 0; +00794 argv[i] = (char *)programName.c_str(); +00795 for (; i < args.size(); i++) +00796 { +00797 argv[i+1] = (char *) args[i].c_str(); +00798 } +00799 argv[i+1] = NULL; +00800 +00801 status = execvp(programName.c_str(), argv); +00802 if (status == -1) +00803 { +00804 perror("Failed launched"); +00805 _exit(EXIT_FAILURE); +00806 } +00807 } +00808 else +00809 { +00810 nldebug("LAUNCH: Successful launch '%s' with arg '%s'", programName.c_str(), arguments.c_str()); +00811 return true; +00812 } +00813 #else +00814 nlwarning ("LAUNCH: launchProgram() not implemented"); +00815 #endif +00816 +00817 return false; +00818 +00819 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T maxof ( const T & a,
const T & b,
const T & c,
const T & d,
const T & e
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 134 of file common.h. +
+References maxof(). +
+
00135 {return std::max(maxof(a,b,c,d),e);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T maxof ( const T & a,
const T & b,
const T & c,
const T & d
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 132 of file common.h. +
+References maxof(). +
+
00133 {return std::max(maxof(a,b,c),d);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T maxof ( const T & a,
const T & b,
const T & c
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 130 of file common.h. +
+Referenced by NLMISC::CRGBA::convertToHLS(), and maxof(). +
+
00131 {return std::max(std::max(a,b),c);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T minof ( const T & a,
const T & b,
const T & c,
const T & d,
const T & e
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 128 of file common.h. +
+References min, and minof(). +
+
00129 {return std::min(minof(a,b,c,d),e);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T minof ( const T & a,
const T & b,
const T & c,
const T & d
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 126 of file common.h. +
+References min, and minof(). +
+
00127 {return std::min(minof(a,b,c),d);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
T minof ( const T & a,
const T & b,
const T & c
) [inline]
+
+ + + + + +
+ + + +
+MIN/MAX extended functions. +
+Definition at line 124 of file common.h. +
+References min. +
+Referenced by NLMISC::CRGBA::convertToHLS(), minof(), NLSOUND::CClusteredSound::update(), and NLMISC::CAABBoxExt::updateRadius(). +
+
00125 {return std::min(std::min(a,b),c);} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CPolygon2D::TVec2fVect::const_iterator Next ( const CPolygon2D::TVec2fVect::const_iterator & it,
const CPolygon2D::TVec2fVect & cont
) [inline, static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1057 of file polygon.cpp. +
+References nlassert, and NLMISC::CPolygon2D::TVec2fVect. +
+Referenced by NLMISC::CPolygon2D::computeBorders(). +
+
01058 { +01059 nlassert(cont.size() != 0); +01060 if ((it + 1) == cont.end()) return cont.begin(); +01061 return (it + 1); +01062 } +

+

+ + + + +
+ + + + + + + + + + +
NL_TRIVIAL_TYPE_TRAITS ( NL3D::CPlaneBasis )
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::nlError ( const char * format,
...
)
+
+ + + + + +
+ + + +
+Never use this function but call the nlerror macro (internal use only). +
+ +
+Definition at line 134 of file debug.cpp. +
+References format, NLMISC_BREAKPOINT, and NLMISC_CONVERT_VARGS. +
+Referenced by NLNET::cbPacsAnswer(). +
+
00135 { +00136 char *str; +00137 NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/); +00138 +00139 NLMISC::DebugNeedAssert = NLMISC::DefaultMsgBoxDisplayer==0; +00140 +00141 NLMISC::ErrorLog->displayNL (str); +00142 +00143 if (NLMISC::DebugNeedAssert) +00144 NLMISC_BREAKPOINT; +00145 +00146 #ifndef NL_OS_WINDOWS +00147 // exit(EXIT_FAILURE); +00148 abort (); +00149 #endif +00150 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLMISC::nlFatalError ( const char * format,
...
)
+
+ + + + + +
+ + + +
+Never use this function (internal use only). +
+ +
+Definition at line 115 of file debug.cpp. +
+References format, NLMISC_BREAKPOINT, and NLMISC_CONVERT_VARGS. +
+
00116 { +00117 char *str; +00118 NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/); +00119 +00120 NLMISC::DebugNeedAssert = NLMISC::DefaultMsgBoxDisplayer==0; +00121 +00122 NLMISC::ErrorLog->displayNL (str); +00123 +00124 if (NLMISC::DebugNeedAssert) +00125 NLMISC_BREAKPOINT; +00126 +00127 #ifndef NL_OS_WINDOWS +00128 // exit(EXIT_FAILURE); +00129 abort (); +00130 #endif +00131 +00132 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
int NLMISC::nlfseek64 ( FILE * stream,
sint64 offset,
int origin
)
+
+ + + + + +
+ + + +
+Signed 64 bit fseek. Same interface than fseek +
+Definition at line 903 of file common.cpp. +
+References min, nlassert, offset, sint, sint64, and SINT64_CONSTANT. +
+Referenced by NLMISC::CBigFile::add(), NLMISC::CIFile::open(), NLMISC::COFile::seek(), and NLMISC::CIFile::seek(). +
+
00904 { +00905 #ifdef NL_OS_WINDOWS +00906 +00907 // +00908 fpos_t pos64 = 0; +00909 switch (origin) +00910 { +00911 case SEEK_CUR: +00912 if (fgetpos(stream, &pos64) != 0) +00913 return -1; +00914 case SEEK_END: +00915 pos64 = _filelengthi64(_fileno(stream)); +00916 if (pos64 == -1L) +00917 return -1; +00918 }; +00919 +00920 // Seek +00921 pos64 += offset; +00922 +00923 // Set the final position +00924 return fsetpos (stream, &pos64); +00925 +00926 #else // NL_OS_WINDOWS +00927 +00928 // This code doesn't work under windows : fseek() implementation uses a signed 32 bits offset. What ever we do, it can't seek more than 2 Go. +00929 // For the moment, i don't know if it works under linux for seek of more than 2 Go. +00930 +00931 nlassert ((offset < SINT64_CONSTANT(2147483647)) && (offset > SINT64_CONSTANT(-2147483648))); +00932 +00933 bool first = true; +00934 do +00935 { +00936 // Get the size of the next fseek +00937 sint nextSeek; +00938 if (offset > 0) +00939 nextSeek = (sint)std::min (SINT64_CONSTANT(2147483647), offset); +00940 else +00941 nextSeek = (sint)std::max (-SINT64_CONSTANT(2147483648), offset); +00942 +00943 // Make a seek +00944 int result = fseek ( stream, nextSeek, first?origin:SEEK_CUR ); +00945 if (result != 0) +00946 return result; +00947 +00948 // Remaining +00949 offset -= nextSeek; +00950 first = false; +00951 } +00952 while (offset); +00953 +00954 return 0; +00955 +00956 #endif // NL_OS_WINDOWS +00957 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( displayMeasures ,
"display hierarchical timer" ,
"" [depth]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1020 of file hierarchical_timer.cpp. +
+
01021 { +01022 if (args.size() < 1) +01023 { +01024 CHTimer::display(&log); +01025 CHTimer::displayHierarchicalByExecutionPathSorted (&log, CHTimer::TotalTime, true, 64); +01026 } +01027 else +01028 { +01029 CHTimer::displaySummary(&log, CHTimer::TotalTime, true, 64, 2, atoi(args[0].c_str())); +01030 } +01031 +01032 return true; +01033 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( playerInfo ,
"Get informations about a player or all players in CEntityIdTranslator" ,
"" [< entityname >|< eid >|< username >|< uid >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 687 of file eid_translator.cpp. +
+References NLMISC::CEntityIdTranslator::getByEntity(), NLMISC::CEntityIdTranslator::getByUser(), NLMISC::CEntityIdTranslator::getEntityIdInfo(), NLMISC::CEntityIdTranslator::getRegisteredEntities(), res, NLMISC::CEntityId::setCreatorId(), NLMISC::CEntityId::setDynamicId(), sint16, sint8, ucstring::toString(), uint, and uint32. +
+
00688 { +00689 if (args.size () == 0) +00690 { +00691 const map<CEntityId, CEntityIdTranslator::CEntity> &res = CEntityIdTranslator::getInstance()->getRegisteredEntities (); +00692 log.displayNL("%d result(s) for 'all players informations'", res.size()); +00693 for (map<CEntityId, CEntityIdTranslator::CEntity>::const_iterator it = res.begin(); it != res.end(); it++) +00694 { +00695 log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s", (*it).second.UId, (*it).second.UserName.c_str(), (*it).first.toString().c_str(), (*it).second.EntityName.toString().c_str(), (sint16)((*it).second.EntitySlot), ((*it).second.Online?"Online":"Offline")); +00696 } +00697 +00698 return true; +00699 } +00700 else if (args.size () == 1) +00701 { +00702 vector<CEntityId> res; +00703 +00704 CEntityId eid (args[0].c_str()); +00705 uint32 uid = atoi (args[0].c_str()); +00706 +00707 if (eid != CEntityId::Unknown) +00708 { +00709 // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array +00710 eid.setCreatorId(0); +00711 eid.setDynamicId(0); +00712 +00713 res.push_back(eid); +00714 } +00715 else if (uid != 0) +00716 { +00717 // the parameter is an uid +00718 CEntityIdTranslator::getInstance()->getByUser (uid, res); +00719 } +00720 else +00721 { +00722 CEntityIdTranslator::getInstance()->getByUser (args[0], res, false); +00723 +00724 CEntityIdTranslator::getInstance()->getByEntity (args[0], res, false); +00725 } +00726 +00727 log.displayNL("%d result(s) for '%s'", res.size(), args[0].c_str()); +00728 for (uint i = 0; i < res.size(); i++) +00729 { +00730 ucstring entityName; +00731 sint8 entitySlot; +00732 uint32 uid2; +00733 string userName; +00734 bool online; +00735 CEntityIdTranslator::getInstance()->getEntityIdInfo (res[i], entityName, entitySlot, uid2, userName, online); +00736 +00737 log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s", uid2, userName.c_str(), res[i].toString().c_str(), entityName.toString().c_str(), (sint16)entitySlot, (online?"Online":"Offline")); +00738 } +00739 +00740 return true; +00741 } +00742 +00743 return false; +00744 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( entityNameValid ,
"Tell if an entity name is valid or not using CEntityIdTranslator validation rulez" ,
"< entityname >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 664 of file eid_translator.cpp. +
+References NLMISC::CEntityIdTranslator::entityNameExists(), and NLMISC::CEntityIdTranslator::isValidEntityName(). +
+
00665 { +00666 if (args.size () != 1) return false; +00667 +00668 if(!CEntityIdTranslator::getInstance()->isValidEntityName(args[0], &log)) +00669 { +00670 log.displayNL("Entity name '%s' is not valid", args[0].c_str()); +00671 } +00672 else +00673 { +00674 if (CEntityIdTranslator::getInstance()->entityNameExists(args[0])) +00675 { +00676 log.displayNL("Entity name '%s' is already used by another player", args[0].c_str()); +00677 } +00678 else +00679 { +00680 log.displayNL("Entity name '%s' is available", args[0].c_str()); +00681 } +00682 } +00683 +00684 return true; +00685 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( findEIdByEntity ,
"Find entity id using the entity name" ,
"< entityname >|< eid >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 633 of file eid_translator.cpp. +
+References NLMISC::CEntityIdTranslator::getByEntity(), NLMISC::CEntityIdTranslator::getEntityIdInfo(), sint16, sint8, ucstring::toString(), NLMISC::CEntityId::toString(), and uint32. +
+
00634 { +00635 if (args.size () != 1) +00636 return false; +00637 +00638 CEntityId eid (args[0].c_str()); +00639 +00640 if (eid == CEntityId::Unknown) +00641 { +00642 eid = CEntityIdTranslator::getInstance()->getByEntity(args[0]); +00643 } +00644 +00645 if (eid == CEntityId::Unknown) +00646 { +00647 log.displayNL("'%s' is not an eid or an entity name", args[0].c_str()); +00648 return false; +00649 } +00650 +00651 ucstring entityName; +00652 sint8 entitySlot; +00653 uint32 uid; +00654 string userName; +00655 bool online; +00656 +00657 CEntityIdTranslator::getInstance()->getEntityIdInfo(eid, entityName, entitySlot, uid, userName, online); +00658 +00659 log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s", uid, userName.c_str(), eid.toString().c_str(), entityName.toString().c_str(), (sint16)entitySlot, (online?"Online":"Offline")); +00660 +00661 return true; +00662 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( findEIdByUser ,
"Find entity ids using the user name" ,
"< username >|< uid >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 603 of file eid_translator.cpp. +
+References NLMISC::CEntityIdTranslator::getByUser(), NLMISC::CEntityIdTranslator::getUId(), NLMISC::CEntityIdTranslator::getUserName(), res, toString(), uint, and uint32. +
+
00604 { +00605 if (args.size () != 1) +00606 return false; +00607 +00608 vector<CEntityId> res; +00609 +00610 string userName = args[0]; +00611 uint32 uid = atoi (userName.c_str()); +00612 +00613 if (uid != 0) +00614 { +00615 CEntityIdTranslator::getInstance()->getByUser(uid, res); +00616 userName = CEntityIdTranslator::getInstance()->getUserName(uid); +00617 } +00618 else +00619 { +00620 CEntityIdTranslator::getInstance()->getByUser(userName, res); +00621 CEntityIdTranslator::getInstance()->getUId(userName); +00622 } +00623 +00624 log.displayNL("User Name '%s' (uid=%d) has %d entities:", userName.c_str(), uid, res.size()); +00625 for (uint i = 0 ; i < res.size(); i++) +00626 { +00627 log.displayNL("> %s %s", res[i].toString().c_str(), CEntityIdTranslator::getInstance()->getByEntity (res[i]).c_str()); +00628 } +00629 +00630 return true; +00631 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( readaccess ,
"read a uint8 value in an invalid address" ,
"" [< adr >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1194 of file debug.cpp. +
+References uint16, uint64, and uint8. +
+
01195 { +01196 uint8 val; +01197 uint8 *adr = (uint8*)0; +01198 if(args.size() == 1) +01199 #ifdef HAVE_X86_64 +01200 adr = (uint8*)(uint64)atoi(args[0].c_str()); +01201 #else +01202 adr = (uint8*)atoi(args[0].c_str()); +01203 #endif +01204 val = *adr; +01205 log.displayNL("value is %hu", (uint16)val); +01206 return true; +01207 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( writeaccess ,
"write a uint8 value in an invalid address" ,
"]" [< adr >[< value >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1179 of file debug.cpp. +
+References uint64, and uint8. +
+
01180 { +01181 uint8 val = 123; +01182 uint8 *adr = (uint8*)0; +01183 if(args.size() >= 1) +01184 #ifdef HAVE_X86_64 +01185 adr = (uint8*)(uint64)atoi(args[0].c_str()); +01186 #else +01187 adr = (uint8*)atoi(args[0].c_str()); +01188 #endif +01189 if(args.size() >= 2) val = (uint8)atoi(args[1].c_str()); +01190 *adr = val; +01191 return true; +01192 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( divbyzero ,
"generate a divide by zero" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1171 of file debug.cpp. +
+
01172 { +01173 if(args.size() != 0) return false; +01174 float a=10,b=0; +01175 a /= b; +01176 return true; +01177 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( abort ,
"generate a abort()" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1164 of file debug.cpp. +
+
01165 { +01166 if(args.size() != 0) return false; +01167 abort(); +01168 return true; +01169 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( stop ,
"generate a nlstop()" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1157 of file debug.cpp. +
+References nlstopex. +
+
01158 { +01159 if(args.size() != 0) return false; +01160 nlstopex (("Stop generated by the stop command")); +01161 return true; +01162 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( assert ,
"generate a failed nlassert()" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1150 of file debug.cpp. +
+References nlassertex. +
+
01151 { +01152 if(args.size() != 0) return false; +01153 nlassertex (false, ("Assert generated by the assert command")); +01154 return true; +01155 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( displayFilterWarning ,
"display filter on WarningLog" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1141 of file debug.cpp. +
+References NLMISC::CLog::displayFilter(), and WarningLog. +
+
01142 { +01143 if(args.size() != 0) return false; +01144 WarningLog->displayFilter(log); +01145 return true; +01146 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( removeFilterWarning ,
"remove a filter on WarningLog" ,
"" [< filterstr >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1131 of file debug.cpp. +
+References NLMISC::CLog::removeFilter(), and WarningLog. +
+
01132 { +01133 if(args.size() == 0) +01134 WarningLog->removeFilter(); +01135 else if(args.size() == 1) +01136 WarningLog->removeFilter( args[0].c_str() ); +01137 else return false; +01138 return true; +01139 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addNegativeFilterWarning ,
"add a negative filter on WarningLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1124 of file debug.cpp. +
+References NLMISC::CLog::addNegativeFilter(), and WarningLog. +
+
01125 { +01126 if(args.size() != 1) return false; +01127 WarningLog->addNegativeFilter( args[0].c_str() ); +01128 return true; +01129 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addPositiveFilterWarning ,
"add a positive filter on WarningLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1117 of file debug.cpp. +
+References NLMISC::CLog::addPositiveFilter(), and WarningLog. +
+
01118 { +01119 if(args.size() != 1) return false; +01120 WarningLog->addPositiveFilter( args[0].c_str() ); +01121 return true; +01122 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( displayFilterInfo ,
"display filter on InfoLog" ,
"" [d|i|w|e]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1094 of file debug.cpp. +
+References DebugLog, NLMISC::CLog::displayFilter(), ErrorLog, InfoLog, and WarningLog. +
+
01095 { +01096 if(args.size() > 1) return false; +01097 if ( args.size() == 1 ) +01098 { +01099 if ( strcmp( args[0].c_str(), "d" ) == 0 ) +01100 InfoLog->displayFilter(*DebugLog); +01101 else if ( strcmp( args[0].c_str(), "i" ) == 0 ) +01102 InfoLog->displayFilter(*InfoLog); +01103 else if ( strcmp( args[0].c_str(), "w" ) == 0 ) +01104 InfoLog->displayFilter(*WarningLog); +01105 else if ( strcmp( args[0].c_str(), "e" ) == 0 ) +01106 InfoLog->displayFilter(*ErrorLog); +01107 else +01108 return false; +01109 } +01110 else +01111 { +01112 InfoLog->displayFilter(log); +01113 } +01114 return true; +01115 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( removeFilterInfo ,
"remove a filter on InfoLog" ,
"" [< filterstr >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1084 of file debug.cpp. +
+References InfoLog, and NLMISC::CLog::removeFilter(). +
+
01085 { +01086 if(args.size() == 0) +01087 InfoLog->removeFilter(); +01088 else if(args.size() == 1) +01089 InfoLog->removeFilter( args[0].c_str() ); +01090 else return false; +01091 return true; +01092 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addNegativeFilterInfo ,
"add a negative filter on InfoLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1077 of file debug.cpp. +
+References NLMISC::CLog::addNegativeFilter(), and InfoLog. +
+
01078 { +01079 if(args.size() != 1) return false; +01080 InfoLog->addNegativeFilter( args[0].c_str() ); +01081 return true; +01082 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addPositiveFilterInfo ,
"add a positive filter on InfoLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1070 of file debug.cpp. +
+References NLMISC::CLog::addPositiveFilter(), and InfoLog. +
+
01071 { +01072 if(args.size() != 1) return false; +01073 InfoLog->addPositiveFilter( args[0].c_str() ); +01074 return true; +01075 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( displayFilterDebug ,
"display filter on DebugLog" ,
""
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1063 of file debug.cpp. +
+References DebugLog, and NLMISC::CLog::displayFilter(). +
+
01064 { +01065 if(args.size() != 0) return false; +01066 DebugLog->displayFilter(log); +01067 return true; +01068 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( removeFilterDebug ,
"remove a filter on DebugLog" ,
"" [< filterstr >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1053 of file debug.cpp. +
+References DebugLog, and NLMISC::CLog::removeFilter(). +
+
01054 { +01055 if(args.size() == 0) +01056 DebugLog->removeFilter(); +01057 else if(args.size() == 1) +01058 DebugLog->removeFilter( args[0].c_str() ); +01059 else return false; +01060 return true; +01061 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addNegativeFilterDebug ,
"add a negative filter on DebugLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1046 of file debug.cpp. +
+References NLMISC::CLog::addNegativeFilter(), and DebugLog. +
+
01047 { +01048 if(args.size() != 1) return false; +01049 DebugLog->addNegativeFilter( args[0].c_str() ); +01050 return true; +01051 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( addPositiveFilterDebug ,
"add a positive filter on DebugLog" ,
"< filterstr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1039 of file debug.cpp. +
+References NLMISC::CLog::addPositiveFilter(), and DebugLog. +
+
01040 { +01041 if(args.size() != 1) return false; +01042 DebugLog->addPositiveFilter( args[0].c_str() ); +01043 return true; +01044 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( resetFilters ,
"disable all filters on Nel loggers" ,
"" [debug|info|warning|error|assert]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1013 of file debug.cpp. +
+References AssertLog, DebugLog, ErrorLog, InfoLog, NLMISC::CLog::resetFilters(), and WarningLog. +
+
01014 { +01015 if(args.size() == 0) +01016 { +01017 DebugLog->resetFilters(); +01018 InfoLog->resetFilters(); +01019 WarningLog->resetFilters(); +01020 ErrorLog->resetFilters(); +01021 AssertLog->resetFilters(); +01022 } +01023 else if (args.size() == 1) +01024 { +01025 if (args[0] == "debug") DebugLog->resetFilters(); +01026 else if (args[0] == "info") InfoLog->resetFilters(); +01027 else if (args[0] == "warning") WarningLog->resetFilters(); +01028 else if (args[0] == "error") ErrorLog->resetFilters(); +01029 else if (args[0] == "assert") AssertLog->resetFilters(); +01030 } +01031 else +01032 { +01033 return false; +01034 } +01035 +01036 return true; +01037 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( displayMemlog ,
"displays the last N line of the log in memory" ,
"" [< NbLines >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 986 of file debug.cpp. +
+References DefaultMemDisplayer, NLMISC::CMemDisplayer::lockStrings(), uint, NLMISC::CMemDisplayer::unlockStrings(), and NLMISC::CMemDisplayer::write(). +
+
00987 { +00988 uint nbLines; +00989 +00990 if (args.size() == 0) nbLines = 100; +00991 else if (args.size() == 1) nbLines = atoi(args[0].c_str()); +00992 else return false; +00993 +00994 if (DefaultMemDisplayer == NULL) return false; +00995 +00996 deque<string>::const_iterator it; +00997 +00998 const deque<string> &str = DefaultMemDisplayer->lockStrings (); +00999 +01000 if (nbLines >= str.size()) +01001 it = str.begin(); +01002 else +01003 it = str.end() - nbLines; +01004 +01005 DefaultMemDisplayer->write (&log); +01006 +01007 DefaultMemDisplayer->unlockStrings (); +01008 +01009 return true; +01010 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( killProgram ,
"kill a program given the pid" ,
"< pid >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1002 of file common.cpp. +
+References killProgram(). +
+
01003 { +01004 if(args.size() != 1) return false; +01005 killProgram(atoi(args[0].c_str())); +01006 return true; +01007 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( launchProgram ,
"Execute the command line using launcProgram() function call(launch in background task without waiting the end of the execution)" ,
"< programName >< arguments >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 990 of file common.cpp. +
+References launchProgram(). +
+
00991 { +00992 if(args.size() != 2) return false; +00993 +00994 string cmd = args[0]; +00995 string arg = args[1]; +00996 log.displayNL ("Executing '%s' with argument '%s'", cmd.c_str(), arg.c_str()); +00997 launchProgram(cmd, arg); +00998 log.displayNL ("End of Execution of '%s' with argument '%s'", cmd.c_str(), arg.c_str()); +00999 return true; +01000 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( system ,
"Execute the command line using system() function call(wait until the end of the command)" ,
"< commandline >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 979 of file common.cpp. +
+
00980 { +00981 if(args.size() != 1) return false; +00982 +00983 string cmd = args[0]; +00984 log.displayNL ("Executing '%s'", cmd.c_str()); +00985 system(cmd.c_str()); +00986 log.displayNL ("End of Execution of '%s'", cmd.c_str()); +00987 return true; +00988 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( sleep ,
"Freeze the service for N seconds(for debug purpose)" ,
"< N >"
)
+
+ + + + + +
+ + + +
+Commands +
+Definition at line 967 of file common.cpp. +
+References nlSleep(), and sint32. +
+
00968 { +00969 if(args.size() != 1) return false; +00970 +00971 sint32 n = atoi (args[0].c_str()); +00972 +00973 log.displayNL ("Sleeping during %d seconds", n); +00974 +00975 nlSleep(n * 1000); +00976 return true; +00977 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( stohr ,
"Convert a second number into an human readable time" ,
"< int >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 526 of file common.cpp. +
+References secondsToHumanReadable(). +
+
00527 { +00528 if (args.size() != 1) +00529 return false; +00530 +00531 log.displayNL("%s -> %s", args[0].c_str(), secondsToHumanReadable(atoi(args[0].c_str())).c_str()); +00532 +00533 return true; +00534 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( hrtob ,
"Convert a human readable number into a bytes number" ,
"< hr >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 465 of file common.cpp. +
+References humanReadableToBytes(). +
+
00466 { +00467 if (args.size() != 1) +00468 return false; +00469 +00470 log.displayNL("%s -> %u", args[0].c_str(), humanReadableToBytes(args[0])); +00471 +00472 return true; +00473 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( btohr ,
"Convert a bytes number into an human readable number" ,
"< int >"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 454 of file common.cpp. +
+References bytesToHumanReadable(). +
+
00455 { +00456 if (args.size() != 1) +00457 return false; +00458 +00459 log.displayNL("%s -> %s", args[0].c_str(), bytesToHumanReadable(args[0]).c_str()); +00460 +00461 return true; +00462 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_COMMAND ( help ,
"display help on a specific variable/commands or on all variables and commands" ,
"" [< variable >|< command >]
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 389 of file command.cpp. +
+References nlassert, and uint. +
+
00390 { +00391 nlassert (Commands != NULL); +00392 +00393 if (args.size() == 0) +00394 { +00395 // display all commands +00396 log.displayNL("There's %d variables and commands: ", (*Commands).size()); +00397 uint i = 0; +00398 for (TCommand::iterator comm = (*Commands).begin(); comm != (*Commands).end(); comm++, i++) +00399 { +00400 log.displayNL("%2d %-15s: %s", i, (*comm).first.c_str(), (*comm).second->HelpString.c_str()); +00401 } +00402 } +00403 else if (args.size() == 1) +00404 { +00405 // display help of the command +00406 TCommand::iterator comm = (*Commands).find(args[0].c_str()); +00407 if (comm == (*Commands).end ()) +00408 { +00409 log.displayNL("command '%s' not found", args[0].c_str()); +00410 } +00411 else +00412 { +00413 log.displayNL("%s", (*comm).second->HelpString.c_str()); +00414 log.displayNL("usage: %s %s", (*comm).first.c_str(), (*comm).second->CommandArgs.c_str(), (*comm).second->HelpString.c_str()); +00415 } +00416 } +00417 else +00418 { +00419 return false; +00420 } +00421 return true; +00422 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_DYNVARIABLE ( string ,
OS ,
"OS used"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 721 of file system_info.cpp. +
+References pointer. +
+
00722 { +00723 if (get) *pointer = CSystemInfo::getOS(); +00724 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_DYNVARIABLE ( string ,
ProcessUsedMemory ,
"Memory used by this process in bytes"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 716 of file system_info.cpp. +
+References bytesToHumanReadable(), and pointer. +
+
00717 { +00718 if (get) *pointer = bytesToHumanReadable(CHeapAllocator::getAllocatedSystemMemory ()); +00719 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_DYNVARIABLE ( string ,
TotalPhysicalMemory ,
"Total physical memory on this computer in bytes"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 711 of file system_info.cpp. +
+References bytesToHumanReadable(), and pointer. +
+
00712 { +00713 if (get) *pointer = bytesToHumanReadable(CSystemInfo::totalPhysicalMemory ()); +00714 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
NLMISC_DYNVARIABLE ( string ,
AvailablePhysicalMemory ,
"Physical memory available on this computer in bytes"
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 706 of file system_info.cpp. +
+References bytesToHumanReadable(), and pointer. +
+
00707 { +00708 if (get) *pointer = bytesToHumanReadable(CSystemInfo::availablePhysicalMemory ()); +00709 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::nlSleep ( uint32 ms )
+
+ + + + + +
+ + + +
+Portable Sleep() function that suspends the execution of the calling thread for a number of milliseconds. Note: the resolution of the timer is system-dependant and may be more than 1 millisecond. +
+Definition at line 73 of file common.cpp. +
+References uint32. +
+Referenced by NLNET::CCallbackNetBase::baseUpdate(), NLNET::CLoginClient::connectToShard(), NLMISC::CSystemInfo::getProcessorFrequency(), NL3D::CZoneLighter::light(), NL3D::CZoneLighter::lightShapes(), NL3D::CLandscapeUser::loadAllZonesAround(), NLMISC::CIFile::loadIntoCache(), NLNET::IService::main(), NLMISC_COMMAND(), NLNET::CNamingClient::queryServicePort(), NL3D::CLandscapeUser::refreshAllZonesAround(), NLPACS::CGlobalRetriever::refreshLrAroundNow(), NLNET::CNamingClient::registerService(), NLNET::CNamingClient::registerServiceWithSId(), CTimeoutAssertionThread::run(), NLNET::CServerReceiveTask::run(), NLAIAGENT::CAgentManagerTimer::CRunTimer::run(), NLMISC::CIFile::serialBuffer(), NLMISC::CTaskManager::sleepTask(), NL3D::UInstanceGroup::stopCreateInstanceGroupAsync(), NLNET::CUnifiedNetwork::update(), NLNET::CNetManager::update(), NLSOUND::CSampleBank::~CSampleBank(), and NLMISC::CTaskManager::~CTaskManager(). +
+
00074 { +00075 #ifdef NL_OS_WINDOWS +00076 +00078 #ifdef NL_DEBUG +00079 ms = max(ms, (uint32)1); +00080 #endif +00081 +00082 Sleep( ms ); +00083 +00084 #elif defined NL_OS_UNIX +00085 usleep( ms*1000 ); +00086 #endif +00087 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint nlstricmp ( const char * lhs,
const std::string & rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 231 of file common.h. +
+References sint, and stricmp(). +
+
00231 { return stricmp(lhs,rhs.c_str()); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint nlstricmp ( const std::string & lhs,
const char * rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 230 of file common.h. +
+References sint, and stricmp(). +
+
00230 { return stricmp(lhs.c_str(),rhs); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint nlstricmp ( const std::string & lhs,
const std::string & rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 229 of file common.h. +
+References sint, and stricmp(). +
+
00229 { return stricmp(lhs.c_str(), rhs.c_str()); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint nlstricmp ( const char * lhs,
const char * rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 228 of file common.h. +
+References sint, and stricmp(). +
+Referenced by NLGEORGES::CMyEvalNumExpr::evalValue(), and NLMISC::CUnsensitiveStrLessPred::operator()(). +
+
00228 { return stricmp(lhs, rhs); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CVectorD operator * ( double f,
const CVectorD & v
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 88 of file vectord_inline.h. +
+References v. +
+
00089 { +00090 CVectorD ret(v.x*f, v.y*f, v.z*f); +00091 return ret; +00092 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CVector operator * ( float f,
const CVector & v
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 88 of file vector_inline.h. +
+References v. +
+
00089 { +00090 CVector ret(v.x*f, v.y*f, v.z*f); +00091 return ret; +00092 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CVector2f operator * ( float f,
const CVector2f & v
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 140 of file vector_2f.h. +
+References v. +
+
00141 { +00142 return v*f; +00143 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CVector2d operator * ( double f,
const CVector2d & v
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 134 of file vector_2d.h. +
+References v. +
+
00135 { +00136 return v*f; +00137 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CUV operator * ( const CUV & uv,
float f
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 92 of file uv.h. +
+
00093 { +00094 return f * uv; +00095 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CUV operator * ( float f,
const CUV & uv
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 86 of file uv.h. +
+References NLMISC::CUV::U, and NLMISC::CUV::V. +
+
00087 { +00088 return CUV(uv.U * f, uv.V * f); +00089 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CRGBAF operator * ( float f,
const CRGBAF & c
) [inline]
+
+ + + + + +
+ + + +
+Mul float operator. Multiplate each component by f.
Parameters:
+ + +
f Float factor.
+
+
Returns:
Return the result
+ +
+Definition at line 669 of file rgba.h. +
+References NLMISC::CRGBAF::A, NLMISC::CRGBAF::B, NLMISC::CRGBAF::G, and NLMISC::CRGBAF::R. +
+
00670 { +00671 return CRGBAF (c.R*f, c.G*f, c.B*f, c.A*f); +00672 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
CQuatT<T> operator * ( T f,
const CQuatT< T > & o
) [inline]
+
+ + + + + +
+ + + +
+f*quat operator +
+ +
+Definition at line 211 of file quat.h. +
+
00211 {return o*f;} +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CPlane operator * ( const CPlane & p,
const CMatrix & m
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1308 of file matrix.cpp. +
+References NLMISC::CPlane::a, NLMISC::CPlane::b, NLMISC::CPlane::c, NLMISC::CPlane::d, MAT_PROJ, MAT_ROT, MAT_SCALEANY, MAT_SCALEUNI, MAT_TRANS, NLMISC::CMatrix::StateBit, NLMISC::CMatrix::testExpandProj(), and NLMISC::CMatrix::testExpandRot(). +
+
01309 { +01310 // \todo yoyo: TODO_OPTIMIZE it... +01311 m.testExpandRot(); +01312 m.testExpandProj(); +01313 +01314 +01315 CPlane ret; +01316 +01317 if( m.StateBit & (MAT_ROT|MAT_SCALEUNI|MAT_SCALEANY|MAT_PROJ) ) +01318 { +01319 // Compose with translation too. +01320 ret.a= p.a*m.a11 + p.b*m.a21 + p.c*m.a31 + p.d*m.a41; +01321 ret.b= p.a*m.a12 + p.b*m.a22 + p.c*m.a32 + p.d*m.a42; +01322 ret.c= p.a*m.a13 + p.b*m.a23 + p.c*m.a33 + p.d*m.a43; +01323 ret.d= p.a*m.a14 + p.b*m.a24 + p.c*m.a34 + p.d*m.a44; +01324 return ret; +01325 } +01326 else if( m.StateBit & MAT_TRANS ) +01327 { +01328 +01329 // Compose just with a translation. +01330 ret.a= p.a; +01331 ret.b= p.b; +01332 ret.c= p.c; +01333 ret.d= p.a*m.a14 + p.b*m.a24 + p.c*m.a34 + p.d*m.a44; +01334 return ret; +01335 } +01336 else // Identity!! +01337 return p; +01338 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool operator!= ( const CGameDeviceDesc & lhs,
const CGameDeviceDesc & rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 60 of file game_device.h. +
+
00061 { +00062 return !(lhs == rhs); +00063 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool operator< ( const CVector2f & lhs,
const CVector2f & rhs
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 146 of file vector_2f.h. +
+References NLMISC::CVector2f::x, and NLMISC::CVector2f::y. +
+
00147 { +00148 return (lhs.x != rhs.x) ? lhs.x < rhs.x : lhs.y < rhs.y; +00149 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::operator< ( const CPolygon2D & lhs,
const CPolygon2D & rhs
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1945 of file polygon.cpp. +
+References uint, and NLMISC::CPolygon2D::Vertices. +
+
01946 { +01947 if (lhs.Vertices.size() != rhs.Vertices.size()) return lhs.Vertices.size() < rhs.Vertices.size(); +01948 for(uint k = 0; k < lhs.Vertices.size(); ++k) +01949 { +01950 if (lhs.Vertices[k] != rhs.Vertices[k]) return lhs.Vertices[k] < rhs.Vertices[k]; +01951 } +01952 return false; +01953 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool operator== ( const CGameDeviceDesc & lhs,
const CGameDeviceDesc & rhs
) [inline]
+
+ + + + + +
+ + + +
+for devices comparison. The 'Connected' field is ignored. +
+ +
+Definition at line 55 of file game_device.h. +
+References NLMISC::CGameDeviceDesc::InstanceName, and NLMISC::CGameDeviceDesc::ProductName. +
+
00056 { +00057 return lhs.InstanceName == rhs.InstanceName && lhs.ProductName == rhs.ProductName; +00058 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::operator== ( const CPolygon2D & lhs,
const CPolygon2D & rhs
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 1938 of file polygon.cpp. +
+References NLMISC::CPolygon2D::Vertices. +
+
01939 { +01940 if (lhs.Vertices.size() != rhs.Vertices.size()) return false; +01941 return std::equal(lhs.Vertices.begin(), lhs.Vertices.end(), rhs.Vertices.begin()); +01942 } +

+

+ + + + +
+ + + + + + + + + + +
sint OptFastFloor ( float x ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 125 of file fast_floor.h. +
+References sint, and x. +
+Referenced by NL3D::CVegetableManager::addInstance(), NL3D::CPatch::appendTileLightInfluences(), NL3D::CHLSColorTexture::compressBlockRGB(), NL3D::computeLodLighting(), NL3D::CLightingManager::computeModelLightContributions(), NL3D::CFastHLSModifier::convertRGBABitmap(), NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NLMISC::CNoiseColorGradient::eval(), NLMISC::CRandomGrid3D::evalBiLinear(), NLMISC::CRandomGrid3D::evalNearest(), NL3D::CVegetable::generateGroupEx(), NL3D::CPatch::generateTileVegetable(), NL3D::CPatch::getLumel(), NL3D::CSurfaceLightGrid::getStaticLightSetup(), NL3D::CPatch::getTileElement(), NL3D::CTessFacePriorityList::insert(), NL3D::CClipTrav::loadBalanceSkeletonCLod(), NL3D::CSpinnerFunctor::operator()(), NL3D::CPSFloatCurveFunctor::operator()(), NL3D::CPSValueGradientFunc< sint32 >::operator()(), NL3D::CPSValueBlendSampleFunc< NLMISC::CRGBA, n >::operator()(), NL3D::CMeshBlender::prepareRenderForGlobalAlphaCoarseMesh(), NL3D::CVegetableManager::render(), NL3D::CMeshMRMSkinnedGeom::render(), NL3D::CMeshMRMGeom::render(), NL3D::CMeshGeom::render(), NL3D::CShadowMapManager::renderProject(), NL3D::CRenderTrav::traverse(), and NL3D::CTransform::traverseLight(). +
+
00126 { +00127 return (sint)floor(x); +00128 } +

+

+ + + + +
+ + + + + + + + + + +
uint32 OptFastFloor24 ( float x ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 138 of file fast_floor.h. +
+References uint32, and x. +
+Referenced by NL3D::CPatchDLMContext::addPointLightInfluence(). +
+
00139 { +00140 return (uint32)floor(x); +00141 } +

+

+ + + + +
+ + + + + + + + + +
void OptFastFloorBegin ( ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 123 of file fast_floor.h. +
+Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), NL3D::CLandscape::refine(), NL3D::CRenderTrav::traverse(), and NL3D::CLandscape::updateLightingAll(). +
+
00123 {} +

+

+ + + + +
+ + + + + + + + + +
void OptFastFloorBegin24 ( ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 136 of file fast_floor.h. +
+Referenced by NL3D::CPatchDLMContext::addPointLightInfluence(). +
+
00136 {} +

+

+ + + + +
+ + + + + + + + + +
void OptFastFloorEnd ( ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 124 of file fast_floor.h. +
+Referenced by NL3D::CPSFaceLookAtHelper::drawLookAt(), NL3D::CPSFaceLookAtHelper::drawLookAtAlignOnMotion(), NL3D::CPSAttribMakerT< T, F >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::get(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::make4(), NL3D::CPSAttribMakerT< uint32, CPSValueBlendFunc< uint32 > >::makeN(), NL3D::CLandscape::refine(), NL3D::CRenderTrav::traverse(), and NL3D::CLandscape::updateLightingAll(). +
+
00124 {} +

+

+ + + + +
+ + + + + + + + + +
void OptFastFloorEnd24 ( ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 137 of file fast_floor.h. +
+Referenced by NL3D::CPatchDLMContext::addPointLightInfluence(). +
+
00137 {} +

+

+ + + + +
+ + + + + + + + + + +
float OptFastFractionnalPart ( float x ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 130 of file fast_floor.h. +
+References sint, and x. +
+
00131 { +00132 return x - (sint) x ; +00133 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
CPolygon2D::TVec2fVect::const_iterator Prev ( const CPolygon2D::TVec2fVect::const_iterator & it,
const CPolygon2D::TVec2fVect & cont
) [inline, static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1067 of file polygon.cpp. +
+References nlassert, and NLMISC::CPolygon2D::TVec2fVect. +
+Referenced by NLMISC::CPolygon2D::computeBorders(). +
+
01068 { +01069 nlassert(cont.size() != 0); +01070 if (it == cont.begin()) return cont.end() - 1; +01071 return (it - 1); +01072 } +

+

+ + + + +
+ + + + + + + + + + +
float radToDeg ( float rad ) [inline]
+
+ + + + + +
+ + + +
+Converts from radians to degrees +
+Definition at line 178 of file common.h. +
+References Pi. +
+Referenced by NLSOUND::CSourceAL::setCone(). +
+
00179 { +00180 return rad * 180.0f / (float)Pi; +00181 } +

+

+ + + + +
+ + + + + + + + + + +
uint NLMISC::raiseToNextPowerOf2 ( uint v )
+
+ + + + + +
+ + + +
+Return the value maximized to the next power of 2 of v. Example: raiseToNextPowerOf2(8) is 8 raiseToNextPowerOf2(5) is 8 +
+Definition at line 349 of file common.cpp. +
+References res, uint, and v. +
+Referenced by NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CIGSurfaceLightBuild::buildPLDebugMesh(), NL3D::CDeform2d::doDeform(), NL3D::CTextureGrouped::doGenerate(), NL3D::CNoise3d::init(), NL3D::SCloudTextureClamp::init(), NL3D::SCloudTexture3D::init(), NL3D::CCloud::init(), NL3D::CShadowMap::initTexture(), NL3D::CCloudScape::makeHalfCloud(), NL3D::CMotionBlur::performMotionBlur(), NL3D::CShadowMapManager::renderGenerate(), NL3D::CScene::setShadowMapTextureSize(), and NL3D::CDeform2d::setupBuffer(). +
+
00350 { +00351 uint res=1; +00352 while(res<v) +00353 res<<=1; +00354 +00355 return res; +00356 } +

+

+ + + + +
+ + + + + + + + + + +
void removeAllUnusedChar ( string & str ) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 280 of file path.cpp. +
+References uint32. +
+Referenced by NLMISC::CPath::loadRemappedFiles(). +
+
00281 { +00282 uint32 i = 0; +00283 while (!str.empty() && (i != str.size())) +00284 { +00285 if ((str[i] == ' ' || str[i] == '\t' || str[i] == '\r' || str[i] == '\n')) +00286 str.erase(str.begin()+i); +00287 else +00288 i++; +00289 } +00290 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::removeSlashR ( std::string str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 50 of file string_common.cpp. +
+References uint. +
+
00051 { +00052 string formatedStr; +00053 // replace \n with \r\n +00054 for (uint i = 0; i < str.size(); i++) +00055 { +00056 if (str[i] != '\r') +00057 formatedStr += str[i]; +00058 } +00059 return formatedStr; +00060 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TReportResult report ( const std::string & title,
const std::string & header,
const std::string & subject,
const std::string & body,
bool enableCheckIgnore,
uint debugButton,
bool ignoreButton,
sint quitButton,
bool sendReportButton,
bool & ignoreNextTime
)
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + +
void report ( )
+
+ + + + + +
+ + + +
+ +
+Definition at line 81 of file report.cpp. +
+Referenced by NLMISC::CHeapAllocator::debugReportMemoryLeak(), and NLMISC::CMsgBoxDisplayer::doDisplay(). +
+
00082 { +00083 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
void rotateCCW ( const T * src,
T * dst,
uint srcWidth,
uint srcHeight
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 2283 of file bitmap.cpp. +
+References src, uint, x, and y. +
+Referenced by NLMISC::CBitmap::rotateCCW(). +
+
02284 { +02285 for (uint y=0; y<srcHeight; y++) +02286 for (uint x=0; x<srcWidth; x++) +02287 { +02288 uint dstX=y; +02289 uint dstY=srcWidth-x-1; +02290 dst[dstX+dstY*srcHeight]=src[x+y*srcWidth]; +02291 } +02292 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T, class U>
T safe_cast ( U o ) [inline]
+
+ + + + + +
+ + + +
+safe_cast<>: this is a function which nlassert() a dynamic_cast in Debug, and just do a static_cast in release. So slow check is made in debug, but only fast cast is made in release. +
+Definition at line 506 of file debug.h. +
+
00510 : this is a function which nlassert() a dynamic_cast in Debug, and just do a static_cast in release. +00511 * So slow check is made in debug, but only fast cast is made in release. +00512 * Differs from safe_cast by allowinf NULL objets. +00513 */ +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ScanEdge ( CPolygon2D::TRasterVect & outputVect,
sint topY,
const CVector2f & v1,
const CVector2f & v2,
bool rightEdge = true
) [static]
+
+ + + + + +
+ + + +
+*************************************************************************************** +
+ +
+Definition at line 1003 of file polygon.cpp. +
+References height, sint, NLMISC::CPolygon2D::TRasterVect, uint, NLMISC::CVector2f::x, and NLMISC::CVector2f::y. +
+Referenced by NLMISC::CPolygon2D::computeBorders(). +
+
01004 { +01005 const uint rol16 = 65536; +01006 sint ceilY1 = (sint) ceilf(v1.y); +01007 sint height; +01008 float deltaX, deltaY; +01009 float fInverseSlope; +01010 sint iInverseSlope, iPosX; +01011 +01012 // check wether this segment gives a contribution to the final poly +01013 height = (sint) (ceilf(v2.y) - ceilY1); +01014 if (height <= 0) return; +01015 +01016 // compute slope +01017 deltaY = v2.y - v1.y; +01018 deltaX = v2.x - v1.x; +01019 fInverseSlope = deltaX / deltaY; +01020 +01021 +01022 CPolygon2D::TRasterVect::iterator outputIt = outputVect.begin() + (ceilY1 - topY); +01023 +01024 // slope with ints +01025 iInverseSlope = (sint) (rol16 * fInverseSlope); +01026 +01027 // sub-pixel accuracy +01028 iPosX = (int) (rol16 * (v1.x + fInverseSlope * (ceilY1 - v1.y))); +01029 +01030 const CPolygon2D::TRasterVect::iterator endIt = outputIt + height; +01031 if (rightEdge) +01032 { +01033 do +01034 { +01035 outputIt->second = iPosX >> 16; +01036 iPosX += iInverseSlope; +01037 ++outputIt; +01038 } +01039 while (outputIt != endIt); +01040 } +01041 else +01042 { +01043 iPosX += (rol16 - 1); +01044 do +01045 { +01046 outputIt->first = iPosX >> 16; +01047 iPosX += iInverseSlope; +01048 ++outputIt; +01049 } +01050 while (outputIt != endIt); +01051 } +01052 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ScanInnerEdge ( CPolygon2D::TRaster * r,
float x1,
float y1,
float x2,
float y2,
sint minY,
bool rightEdge
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1517 of file polygon.cpp. +
+References height, min, r, sint, sint32, NLMISC::CPolygon2D::TRaster, and uint. +
+Referenced by NLMISC::CPolygon2D::computeInnerBorders(). +
+
01518 { +01519 const uint rol16 = 65536; +01520 CPolygon2D::TRaster *currRaster; +01521 float deltaX, deltaY; +01522 float inverseSlope; +01523 sint32 iInverseSlope, iposx; +01524 sint height; +01525 deltaX = x2 - x1; +01526 height = (sint) (ceilf(y2) - floorf(y1)); +01527 if (height <= 0) return; +01528 deltaY = y2 - y1; +01529 inverseSlope = deltaX / deltaY; +01530 iInverseSlope = (sint32) (rol16 * inverseSlope); +01531 currRaster = r + ((sint) floorf(y1) - minY); +01532 iposx = (sint32) (rol16 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy +01533 if (rightEdge) +01534 { +01535 iposx -= rol16 - 1; +01536 if (deltaX >= 0.f) +01537 { +01538 // start of segment +01539 if (floorf(y1) != y1) +01540 { +01541 currRaster->second = std::min((sint) floorf(x1) - 1, currRaster->second); +01542 ++ currRaster; +01543 -- height; +01544 if (height == 0) return; +01545 } +01546 do +01547 { +01548 currRaster->second = std::min((sint) (iposx >> 16), currRaster->second); +01549 iposx += iInverseSlope; +01550 ++ currRaster; +01551 } +01552 while (--height); +01553 } +01554 else +01555 { +01556 // start of segment +01557 if (floorf(y1) != y1) +01558 { +01559 currRaster->second = std::min((sint) (iposx >> 16), currRaster->second); +01560 ++ currRaster; +01561 -- height; +01562 if (height == 0) return; +01563 } +01564 while (--height) +01565 { +01566 iposx += iInverseSlope; +01567 currRaster->second = std::min((sint) (iposx >> 16), currRaster->second); +01568 ++ currRaster; +01569 } +01570 // fill bottom of segment +01571 currRaster->second = std::min((sint) floorf(x2) - 1, currRaster->second); +01572 } +01573 } +01574 else +01575 { +01576 iposx += rol16 - 1; +01577 if (deltaX < 0.f) +01578 { +01579 // start of segment +01580 if (floorf(y1) != y1) +01581 { +01582 currRaster->first = std::max((sint) ceilf(x1), currRaster->first); +01583 ++ currRaster; +01584 -- height; +01585 if (height == 0) return; +01586 } +01587 do +01588 { +01589 currRaster->first = std::max((sint) (iposx >> 16), currRaster->first); +01590 iposx += iInverseSlope; +01591 ++ currRaster; +01592 } +01593 while (--height); +01594 } +01595 else +01596 { +01597 // start of segment +01598 if (floorf(y1) != y1) +01599 { +01600 currRaster->first = std::max((sint) (iposx >> 16), currRaster->first); +01601 ++ currRaster; +01602 -- height; +01603 if (height == 0) return; +01604 } +01605 while (--height) +01606 { +01607 iposx += iInverseSlope; +01608 currRaster->first = std::max((sint) (iposx >> 16), currRaster->first); +01609 ++ currRaster; +01610 } +01611 // fill bottom of segment +01612 currRaster->first = std::max((sint) ceilf(x1), currRaster->first); +01613 } +01614 } +01615 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ScanOuterEdgeLeft ( CPolygon2D::TRaster * r,
float x1,
float y1,
float x2,
float y2,
sint minY
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1288 of file polygon.cpp. +
+References height, min, r, sint, sint32, and NLMISC::CPolygon2D::TRaster. +
+Referenced by NLMISC::CPolygon2D::computeOuterBorders(). +
+
01289 { +01290 CPolygon2D::TRaster *currRaster; +01291 float deltaX, deltaY; +01292 float inverseSlope; +01293 sint32 iInverseSlope, iposx; +01294 sint height; +01295 deltaX = x2 - x1; +01296 height = (sint) (ceilf(y2) - floorf(y1)) ; +01297 if (height <= 0) return; +01298 if (deltaX < 0.f) +01299 { +01300 if (height == 1) +01301 { +01302 currRaster = r + ((sint) floorf(y1) - minY); +01303 currRaster->first = std::min((sint) floorf(x2), currRaster->first); +01304 } +01305 else +01306 { +01307 deltaY = y2 - y1; +01308 inverseSlope = deltaX / deltaY; +01309 iInverseSlope = (sint32) (65536.0 * inverseSlope); +01310 currRaster = r + ((sint) floorf(y1) - minY); +01311 iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy +01312 do +01313 { +01314 currRaster->first = std::min((sint) (iposx >> 16), currRaster->first); +01315 iposx += iInverseSlope; +01316 ++ currRaster; +01317 -- height; +01318 } +01319 while (height != 1); +01320 // correction for last line +01321 currRaster->first = std::min((sint) floorf(x2), currRaster->first); +01322 } +01323 } +01324 else +01325 { +01326 deltaY = y2 - y1; +01327 inverseSlope = deltaX / deltaY; +01328 iInverseSlope = (sint32) (65536.0 * inverseSlope); +01329 currRaster = r + ((sint) floorf(y1) - minY); +01330 currRaster->first = std::min((sint) floorf(x1), currRaster->first); +01331 ++ currRaster; +01332 iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy +01333 while (--height) +01334 { +01335 currRaster->first = std::min((sint) (iposx >> 16), currRaster->first); +01336 iposx += iInverseSlope; +01337 ++ currRaster; +01338 } +01339 } +01340 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void ScanOuterEdgeRight ( CPolygon2D::TRaster * r,
float x1,
float y1,
float x2,
float y2,
sint minY
) [static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 1232 of file polygon.cpp. +
+References height, r, sint, sint32, and NLMISC::CPolygon2D::TRaster. +
+Referenced by NLMISC::CPolygon2D::computeOuterBorders(). +
+
01233 { +01234 CPolygon2D::TRaster *currRaster; +01235 float deltaX, deltaY; +01236 float inverseSlope; +01237 sint32 iInverseSlope, iposx; +01238 sint height; +01239 deltaX = x2 - x1; +01240 height = (sint) (ceilf(y2) - floorf(y1)) ; +01241 if (height <= 0) return; +01242 if (deltaX >= 0.f) +01243 { +01244 if (height == 1) +01245 { +01246 currRaster = r + ((sint) floorf(y1) - minY); +01247 currRaster->second = std::max((sint) floorf(x2), currRaster->second); +01248 } +01249 else +01250 { +01251 deltaY = y2 - y1; +01252 inverseSlope = deltaX / deltaY; +01253 iInverseSlope = (sint32) (65536.0 * inverseSlope); +01254 currRaster = r + ((sint) floorf(y1) - minY); +01255 iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy +01256 do +01257 { +01258 currRaster->second = std::max((sint) (iposx >> 16), currRaster->second); +01259 iposx += iInverseSlope; +01260 ++ currRaster; +01261 -- height; +01262 } +01263 while (height != 1); +01264 // correction for last line +01265 currRaster->second = std::max((sint) floorf(x2), currRaster->second); +01266 } +01267 } +01268 else +01269 { +01270 deltaY = y2 - y1; +01271 inverseSlope = deltaX / deltaY; +01272 iInverseSlope = (sint32) (65536.0 * inverseSlope); +01273 currRaster = r + ((sint) floorf(y1) - minY); +01274 currRaster->second = std::max((sint) floorf(x1), currRaster->second); +01275 ++ currRaster; +01276 iposx = (sint32) (65536.0 * (x1 + inverseSlope * (ceilf(y1) - y1))); // sub-pixel accuracy +01277 while (--height) +01278 { +01279 currRaster->second = std::max((sint) (iposx >> 16), currRaster->second); +01280 iposx += iInverseSlope; +01281 ++ currRaster; +01282 } +01283 } +01284 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
uint searchLowerBound ( const std::vector< T > & array,
const T & key
)
+
+ + + + + +
+ + + +
+Search the lower_bound in a sorted array of Value, in growing order (0, 1, 2....). operator<= is used to perform the comparison. It return the first element such that array[id]<=key If not possible, 0 is returned NB: but 0 may still be a good value, so you must check wether or not 0 means "Not found", or "Id 0". +
+Definition at line 109 of file algo.h. +
+References searchLowerBound(), size, and uint. +
+
00110 { +00111 uint size= array.size(); +00112 if(size==0) +00113 return 0; +00114 else +00115 return searchLowerBound(&array[0], size, key); +00116 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T>
uint searchLowerBound ( const T * array,
uint arraySize,
const T & key
)
+
+ + + + + +
+ + + +
+Search the lower_bound in a sorted array of Value, in growing order (0, 1, 2....). operator<= is used to perform the comparison. It return the first element such that array[id]<=key If not possible, 0 is returned NB: but 0 may still be a good value, so you must check wether or not 0 means "Not found", or "Id 0". +
+Definition at line 82 of file algo.h. +
+References uint. +
+Referenced by NL3D::CTrackSampledCommon::evalTime(), NL3D::CHLSTextureManager::findTexture(), and searchLowerBound(). +
+
00083 { +00084 uint start=0; +00085 uint end= arraySize; +00086 // find lower_bound by dichotomy +00087 while(end-1>start) +00088 { +00089 uint pivot= (end+start)/2; +00090 // return the lower_bound, ie return first start with array[pivot]<=key +00091 if(array[pivot] <= key) +00092 start= pivot; +00093 else +00094 end= pivot; +00095 } +00096 +00097 return start; +00098 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::secondsToHumanReadable ( uint32 time )
+
+ + + + + +
+ + + +
+Convert a time into a string that is easily readable by an human, for example 3600 -> "1h". +
+ +
+Definition at line 476 of file common.cpp. +
+References res, toString(), uint, and uint32. +
+Referenced by NLMISC_COMMAND(), and NLNET::NLMISC_DYNVARIABLE(). +
+
00477 { +00478 static char *divTable[] = { "s", "mn", "h", "d" }; +00479 static uint divCoef[] = { 60, 60, 24 }; +00480 uint div = 0; +00481 uint32 res = time; +00482 uint32 newres = res; +00483 while (true) +00484 { +00485 if(div > 2) +00486 break; +00487 +00488 newres /= divCoef[div]; +00489 +00490 if(newres < 3) +00491 break; +00492 +00493 div++; +00494 res = newres; +00495 } +00496 return toString ("%u%s", res, divTable[div]); +00497 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::setAssert ( bool assert )
+
+ + + + + +
+ + + +
+ +
+Definition at line 110 of file debug.cpp. +
+References assert, and NoAssert. +
+Referenced by NLNET::IService::main(). +
+
00111 { +00112 NoAssert = !assert; +00113 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::setCrashCallback ( TCrashCallback crashCallback )
+
+ + + + + +
+ + + +
+ +
+Definition at line 104 of file debug.cpp. +
+References CrashCallback, and TCrashCallback. +
+
00105 { +00106 CrashCallback = crashCallback; +00107 } +

+

+ + + + +
+ + + + + + + + + + +
void NLMISC::setReportEmailFunction ( void * emailFunction )
+
+ + + + + +
+ + + +
+call this in the main of your appli to enable email: setReportEmailFunction (sendEmail); +
+Definition at line 67 of file report.cpp. +
+References EmailFunction, and TEmailFunction. +
+Referenced by NLNET::IService::main(). +
+
00068 { +00069 EmailFunction = (TEmailFunction)emailFunction; +00070 +00071 #ifdef NL_OS_WINDOWS +00072 if (sendReport) +00073 EnableWindow(sendReport, FALSE); +00074 #endif +00075 } +

+

+ + + + +
+ + + + + + + + + + +
char* skipToken ( const char * p ) [inline, static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2259 of file misc/heap_allocator.cpp. +
+Referenced by NLMISC::CHeapAllocator::getAllocatedSystemMemory(). +
+
02260 { +02261 while (isspace(*p)) p++; +02262 while (*p && !isspace(*p)) p++; +02263 return (char *)p; +02264 } +

+

+ + + + +
+ + + + + + + + + + +
char* skipWS ( const char * p ) [inline, static]
+
+ + + + + +
+ + + +
+ +
+Definition at line 2253 of file misc/heap_allocator.cpp. +
+Referenced by NLMISC::CHeapAllocator::getAllocatedSystemMemory(). +
+
02254 { +02255 while (isspace(*p)) p++; +02256 return (char *)p; +02257 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
sint NLMISC::smprintf ( char * buffer,
size_t count,
const char * format,
...
)
+
+ + + + + +
+ + + +
+sMart sprintf function. This function do a sprintf and add a zero at the end of the buffer if there no enough room in the buffer.
+
Parameters:
+ + + + +
buffer a C string
count Size of the buffer
format of the string, it must be the last argument before the '...'
+
+ +
+Definition at line 161 of file common.cpp. +
+References buffer, count, format, and sint. +
+Referenced by NLMISC::IDisplayer::dateToComputerString(), NLMISC::CHeapAllocator::debugReportMemoryLeak(), NLMISC::CHTimer::display(), NLMISC::CBufFIFO::display(), NLMISC::CHTimer::displayByExecutionPath(), NLMISC::EBadSize::EBadSize(), NLMISC::EBadType::EBadType(), NLMISC::EFileNotFound::EFileNotFound(), NL3D::CDriverGL::endProfileVBHardLock(), NLMISC::EParseError::EParseError(), NLMISC::EUnknownVar::EUnknownVar(), NLGEORGES::CFormElmArray::getFormName(), NL3D::CFontGenerator::getFT2Error(), NLGEORGES::CFormElm::getIternalNodeByName(), NL3D::CTextureBlend::getShareName(), NL3D::CDriverGL::getSpecularCubeMap(), NLMISC::CHTimer::CStats::getStats(), NLNET::_CUniTime::getStringUniTime(), NL3D::IDriver::getTextureShareName(), NL3D::CDriverGL::getVideocardInformation(), NLLOGIC::getXMLProp(), NLMISC::IDisplayer::HeaderString(), NLMISC::CFile::isDirectory(), NLSOUND::CSoundAnimation::save(), NLNET::CLoginCookie::setToString(), NLGEORGES::CFormElm::setValueByName(), NLGEORGES::warning(), NLGEORGES::CFileHeader::write(), and NLLOGIC::xmlCheckNodeName(). +
+
00162 { +00163 sint ret; +00164 +00165 va_list args; +00166 va_start( args, format ); +00167 ret = vsnprintf( buffer, count, format, args ); +00168 if ( ret == -1 ) +00169 { +00170 buffer[count-1] = '\0'; +00171 } +00172 va_end( args ); +00173 +00174 return( ret ); +00175 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLMISC::splitString ( const std::string & str,
const std::string & separator,
std::vector< std::string > & retList
)
+
+ + + + + +
+ + + +
+From a string with some separator, build a vector of string. eg: splitString("hello|bye|||bee", "|", list) return 3 string into list: "hello", "bye" and "bee". +
+Definition at line 122 of file algo.cpp. +
+References uint. +
+
00123 { +00124 uint pos=0; +00125 uint newPos=0; +00126 retList.clear(); +00127 while( (newPos= str.find(separator,pos)) != string::npos) +00128 { +00129 // if not empty sub str. (skip repetition of separator ) +00130 if(newPos-pos>0) +00131 retList.push_back(str.substr(pos, newPos-pos)); +00132 // skip token +00133 pos= newPos+separator.size(); +00134 } +00135 // copy the last substr +00136 if( pos<(uint)str.size() ) +00137 retList.push_back(str.substr(pos, str.size()-pos)); +00138 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
T sqr ( const T & v ) [inline]
+
+ + + + + +
+ + + +
+Return the square of a number +
+Definition at line 107 of file common.h. +
+References v. +
+Referenced by NLMISC::CHTimer::CStats::buildFromNodes(), NL3D::CLVBSqrDistLUT::CLVBSqrDistLUT(), NL3D::CPatchDLMPointLight::compile(), NL3D::CLodCharacterShapeBuild::compile(), NL3D::CHLSColorTexture::compressBlockRGB(), NL3D::CTessVertex::computeGeomPos(), NL3D::CPointLight::computeLinearAttenuation(), NL3D::CPatch::computeNewFar(), NL3D::CTessFace::computeTileEMForUpdateRefine(), NL3D::CTessFace::computeTileErrorMetric(), NL3D::CVegetable::generateGroupEx(), NLPACS::CSurfaceQuadTree::getInterpZ(), NL3D::CVisualCollisionEntity::getPatchTriangleUnderUs(), NL3D::CLandscape::getTesselatedPos(), NL3D::CPSFloatCurveFunctor::getValue(), NLMISC::CBSphere::include(), NLMISC::CBSphere::intersect(), NL3D::CCameraCol::minimizeDistanceAgainstTri(), NL3D::CTessFace::updateErrorMetric(), and NL3D::CLandscape::updateGlobalsAndLockBuffers(). +
+
00108 { +00109 return v * v; +00110 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T, class U>
bool strFindReplace ( T & str,
const char * strFind,
const U & strReplace
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 188 of file algo.h. +
+References strFindReplace(). +
+
00189 { +00190 T tempStr= strFind; +00191 return strFindReplace(str, tempStr, strReplace); +00192 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+template<class T, class U>
bool strFindReplace ( T & str,
const T & strFind,
const U & strReplace
)
+
+ + + + + +
+ + + +
+In a string or ucstring, find a substr and replace it with an other. return true if replaced. +
+ +
+Definition at line 176 of file algo.h. +
+References uint. +
+Referenced by strFindReplace(). +
+
00177 { +00178 uint pos= str.find(strFind); +00179 if(pos != T::npos) +00180 { +00181 str.replace(pos, strFind.size(), T(strReplace) ); +00182 return true; +00183 } +00184 else return false; +00185 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
int stricmp ( const char * lhs,
const char * rhs
) [inline]
+
+ + + + + +
+ + + +
+Compare 2 C-Style strings without regard to case
Returns:
0 if strings are equal, < 0 if lhs < rhs, > 0 if lhs > rhs
+On Windows, use stricmp On GNU/Linux, create stricmp using strcasecmp and use stricmp +
+Definition at line 225 of file common.h. +
+Referenced by NLMISC::CSString::icompare(), nlstricmp(), NLMISC::CSString::operator!=(), NLMISC::CSString::operator<(), NLMISC::CSString::operator<=(), NLMISC::CSString::operator==(), NLMISC::CSString::operator>(), and NLMISC::CSString::operator>=(). +
+
00225 { return strcasecmp(lhs, rhs); } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
std::string stringFromVector ( const std::vector< uint8 > & v,
bool limited = true
)
+
+ + + + + +
+ + + +
+Returns a readable string from a vector of bytes. unprintable char are replaced by '?'. +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
string stringFromVector ( const vector< uint8 > & v,
bool limited
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 107 of file common.cpp. +
+References s, size, uint8, and v. +
+Referenced by NLNET::CBufServer::dataAvailable(), NLNET::CBufClient::dataAvailable(), and NLNET::CNonBlockingBufSock::receivePart(). +
+
00108 { +00109 string s; +00110 +00111 if (!v.empty()) +00112 { +00113 int size = v.size (); +00114 if (limited && size > 1000) +00115 { +00116 string middle = "...<buf too big,skip middle part>..."; +00117 s.resize (1000 + middle.size()); +00118 memcpy (&*s.begin(), &*v.begin(), 500); +00119 memcpy (&*s.begin()+500, &*middle.begin(), middle.size()); +00120 memcpy (&*s.begin()+500+middle.size(), &*v.begin()+size-500, 500); +00121 } +00122 else +00123 { +00124 s.resize (size); +00125 memcpy( &*s.begin(), &*v.begin(), v.size() ); +00126 } +00127 +00128 // Replace '\0' characters +00129 string::iterator is; +00130 for ( is=s.begin(); is!=s.end(); ++is ) +00131 { +00132 // remplace non printable char and % with '?' chat +00133 if ( ! isprint((uint8)(*is)) || (*is) == '%') +00134 { +00135 (*is) = '?'; +00136 } +00137 } +00138 } +00139 /* +00140 if ( ! v.empty() ) +00141 { +00142 // Copy contents +00143 s.resize( v.size() ); +00144 memcpy( &*s.begin(), &*v.begin(), v.size() ); +00145 +00146 // Replace '\0' characters +00147 string::iterator is; +00148 for ( is=s.begin(); is!=s.end(); ++is ) +00149 { +00150 // remplace non printable char and % with '?' chat +00151 if ( ! isprint((*is)) || (*is) == '%') +00152 { +00153 (*is) = '?'; +00154 } +00155 } +00156 } +00157 */ return s; +00158 } +

+

+ + + + +
+ + + + + + + + + + +
char * NLMISC::strlwr ( char * str )
+
+ + + + + +
+ + + +
+Convert a string in lower case.
Parameters:
+ + +
a pointer to char to transform to lower case
+
+ +
+Definition at line 564 of file common.cpp. +
+
00565 { +00566 if (str == NULL) +00567 return NULL; +00568 +00569 while (*str != '\0') +00570 { +00571 if ( (*str >= 'A') && (*str <= 'Z') ) +00572 { +00573 *str = *str - 'A' + 'a'; +00574 } +00575 str++; +00576 } +00577 +00578 return str; +00579 } +

+

+ + + + +
+ + + + + + + + + + +
std::string & NLMISC::strlwr ( std::string & str )
+
+ + + + + +
+ + + +
+Convert a string in lower case.
Parameters:
+ + +
a string to transform to lower case
+
+ +
+Definition at line 551 of file common.cpp. +
+References uint. +
+
00552 { +00553 for (uint i = 0; i < str.size(); i++) +00554 { +00555 if ( (str[i] >= 'A') && (str[i] <= 'Z') ) +00556 { +00557 str[i] = str[i] - 'A' + 'a'; +00558 } +00559 } +00560 +00561 return str; +00562 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::strlwr ( const std::string & str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 536 of file common.cpp. +
+References res, and uint. +
+Referenced by NL3D::CShapeBank::add(), NLMISC::CBigFile::add(), NL3D::CShapeBank::addRef(), NL3D::CHLSTextureBank::addTextureInstance(), NL3D::CAsyncTextureManager::addTextureRef(), NL3D::CInstanceGroup::addToSceneAsync(), NLLIGO::CPrimitiveConfigurations::belong(), NLMISC::CSheetId::build(), NL3D::CCoarseMeshBuild::buildBitmap(), NL3D::CShapeBank::cancelLoadAsync(), NLGEORGES::CFormElm::convertValue(), NL3D::CScene::createInstance(), NL3D::CScene::createInstanceAsync(), NLMISC::ICommand::expand(), NL3D::CHLSTextureManager::findTexture(), NLMISC::CEntityIdTranslator::getByEntity(), NLMISC::CEntityIdTranslator::getByUser(), NLGEORGES::CFormDfn::getDependencies(), NLGEORGES::CForm::getDependencies(), NL3D::CTileBank::getDisplacementMap(), NLMISC::CBigFile::getFile(), NLMISC::CBigFile::getFileNamePtr(), NL3D::CTileBank::getNumBitmap(), NLMISC::CEntityIdTranslator::getRegisterableString(), NL3D::CShapeBank::getShape(), NL3D::CInstanceGroup::getShapeName(), NL3D::CTextureFile::getShareName(), NL3D::IDriver::getTextureShareName(), H_AUTO_DECL(), NL3D::CShapeBank::isPresent(), NL3D::CShapeBank::linkShapeToShapeCache(), NLMISC::CBigFile::list(), NL3D::CShapeBank::load(), NL3D::CShapeBank::loadAsync(), NLGEORGES::CFormLoader::loadForm(), NLGEORGES::CFormLoader::loadFormDfn(), NLMISC::CSheetId::loadSheetAlias(), NLMISC::CSheetId::loadSheetId(), NLGEORGES::CFormLoader::loadType(), NLMISC::CSheetId::operator=(), NL3D::CShapeBank::preLoadShapes(), NLLIGO::CPrimitiveClass::read(), NL3D::CCoarseMeshBuild::remapCoordinates(), NLMISC::CPath::remapExtension(), NLMISC::CPath::remapFile(), NL3D::CDriverGL::retrieveATIDriverVersion(), NLNET::sendEmail(), NL3D::CInstanceGroup::stopAddToSceneAsync(), and NLMISC::CSheetId::typeFromFileExtension(). +
+
00537 { +00538 string res; +00539 res.reserve (str.size()); +00540 for (uint i = 0; i < str.size(); i++) +00541 { +00542 if ( (str[i] >= 'A') && (str[i] <= 'Z') ) +00543 res += str[i] - 'A' + 'a'; +00544 else +00545 res += str[i]; +00546 } +00547 +00548 return res; +00549 } +

+

+ + + + +
+ + + + + + + + + + +
char * NLMISC::strupr ( char * str )
+
+ + + + + +
+ + + +
+Convert a string in upper case.
Parameters:
+ + +
a pointer to char to transform to upper case
+
+ +
+Definition at line 610 of file common.cpp. +
+
00611 { +00612 if (str == NULL) +00613 return NULL; +00614 +00615 while (*str != '\0') +00616 { +00617 if ( (*str >= 'a') && (*str <= 'z') ) +00618 { +00619 *str = *str - 'a' + 'A'; +00620 } +00621 str++; +00622 } +00623 +00624 return str; +00625 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::strupr ( const std::string & str )
+
+ + + + + +
+ + + +
+ +
+Definition at line 594 of file common.cpp. +
+References res, and uint. +
+
00595 { +00596 string res; +00597 res.reserve (str.size()); +00598 for (uint i = 0; i < str.size(); i++) +00599 { +00600 if ( (str[i] >= 'a') && (str[i] <= 'z') ) +00601 res += str[i] - 'a' + 'A'; +00602 else +00603 res += str[i]; +00604 } +00605 +00606 return res; +00607 } +

+

+ + + + +
+ + + + + + + + + + +
std::string & NLMISC::strupr ( std::string & str )
+
+ + + + + +
+ + + +
+Convert a string in upper case.
Parameters:
+ + +
a string to transform to upper case
+
+ +
+Definition at line 581 of file common.cpp. +
+References uint. +
+Referenced by H_AUTO_DECL(), and NLNET::IService::main(). +
+
00582 { +00583 for (uint i = 0; i < str.size(); i++) +00584 { +00585 if ( (str[i] >= 'a') && (str[i] <= 'z') ) +00586 { +00587 str[i] = str[i] - 'a' + 'A'; +00588 } +00589 } +00590 +00591 return str; +00592 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::testWildCard ( const char * strIn,
const char * wildCard
)
+
+ + + + + +
+ + + +
+return true if the string strIn verify the wildcard string wildCard. eg: testWildCard("azert", "*")== true testWildCard("azert", "??er*")== true testWildCard("azert", "*er*")== true testWildCard("azert", "azert*")== true Undefined result if s has some '*', return false if wildcard has some "**" or "*?" NB: case-sensitive +
+Definition at line 45 of file algo.cpp. +
+References testWildCard(), and uint. +
+
00046 { +00047 // run the 2 string in //el +00048 while(*wildCard!=0 && *strIn!=0) +00049 { +00050 // if same char, continue. +00051 if(*wildCard==*strIn) +00052 { +00053 wildCard++; +00054 strIn++; +00055 } +00056 // if wildCard is ?, continue +00057 else if(*wildCard=='?') +00058 { +00059 wildCard++; +00060 strIn++; +00061 } +00062 // if wildcard is *, recurs check. +00063 else if(*wildCard=='*') +00064 { +00065 wildCard++; +00066 // if last *, its OK. +00067 if(*wildCard==0) +00068 return true; +00069 // else must check next strings. +00070 else +00071 { +00072 // build the wilcard token. eg from "*pipo?", take "pipo" +00073 string token; +00074 while(*wildCard!='*' && *wildCard!='?' && *wildCard!=0) +00075 { +00076 token+= *wildCard; +00077 wildCard++; +00078 } +00079 // if token size is empty, error +00080 if(token.empty()) +00081 return false; +00082 +00083 // in strIn, search all the occurence of token. For each solution, recurs test. +00084 string sCopy= strIn; +00085 uint pos= sCopy.find(token, 0); +00086 while(pos!=string::npos) +00087 { +00088 // do a testWildCard test on the remaining string/wildCard +00089 if( testWildCard(strIn+pos+token.size(), wildCard) ) +00090 // if succeed, end +00091 return true; +00092 // fails=> test with an other occurence of token in the string. +00093 pos= sCopy.find(token, pos+1); +00094 } +00095 +00096 // if all failed, fail +00097 return false; +00098 } +00099 } +00100 // else fail +00101 else +00102 return false; +00103 } +00104 +00105 // If quit here because end Of 2 strs, OK. +00106 if(*wildCard==0 && *strIn==0) +00107 return true; +00108 // if quit here because wildCard=="*" and s="", OK too. +00109 if(*strIn==0 && wildCard[0]=='*' && wildCard[1]==0) +00110 return true; +00111 +00112 /* +00113 Else false: +00114 It may be wildCard="?aez" and s="" => error +00115 It may be wildCard="" and s="aer" => error +00116 */ +00117 return false; +00118 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLMISC::testWildCard ( const std::string & strIn,
const std::string & wildCard
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 38 of file algo.cpp. +
+Referenced by NLMISC::CEntityIdTranslator::isValidEntityName(), NL3D::CShapeBank::preLoadShapes(), and testWildCard(). +
+
00039 { +00040 return testWildCard(strIn.c_str(), wildCard.c_str()); +00041 } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const std::string & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 197 of file string_common.h. +
+
00197 { return val; } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const bool & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 196 of file string_common.h. +
+References toString(). +
+
00196 { return toString("%u", val?1:0); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const double & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 195 of file string_common.h. +
+References toString(). +
+
00195 { return toString("%lf", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const float & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 194 of file string_common.h. +
+References toString(). +
+
00194 { return toString("%f", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const sint64 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 193 of file string_common.h. +
+References NL_I64, sint64, and toString(). +
+
00193 { return toString("%"NL_I64"d", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const uint64 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 192 of file string_common.h. +
+References NL_I64, toString(), and uint64. +
+
00192 { return toString("%"NL_I64"u", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const sint32 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 191 of file string_common.h. +
+References sint32, and toString(). +
+
00191 { return toString("%d", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const uint32 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 190 of file string_common.h. +
+References toString(), and uint32. +
+
00190 { return toString("%u", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const sint16 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 189 of file string_common.h. +
+References sint16, and toString(). +
+
00189 { return toString("%hd", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const uint16 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 188 of file string_common.h. +
+References toString(), and uint16. +
+
00188 { return toString("%hu", val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const sint8 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 187 of file string_common.h. +
+References sint16, sint8, and toString(). +
+
00187 { return toString("%hd", (sint16)val); } +

+

+ + + + +
+ + + + + + + + + + +
std::string toString ( const uint8 & val ) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 186 of file string_common.h. +
+References toString(), uint16, and uint8. +
+
00186 { return toString("%hu", (uint16)val); } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
std::string toString ( const T & obj )
+
+ + + + + +
+ + + +
+Template Object toString.
Parameters:
+ + +
obj any object providing a "std::string toString()" method. The object doesn't have to derive from anything.
+
+the VC++ error "error C2228: left of '.toString' must have class/struct/union type" means you don't provide a toString() method to your object. +
+Definition at line 180 of file string_common.h. +
+
00181 { +00182 return obj.toString(); +00183 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
std::string toString ( const char * format,
...
) [inline]
+
+ + + + + +
+ + + +
+ +
+Definition at line 157 of file string_common.h. +
+References format, and NLMISC_CONVERT_VARGS. +
+
00159 { +00160 std::string Result; +00161 NLMISC_CONVERT_VARGS(Result, format, NLMISC::MaxCStringSize); +00162 return Result; +00163 } +

+

+ + + + +
+ + + + + + + + + + +
std::string NLMISC::toString ( NL3D::CPSEmitter::TEmissionType type )
+
+ + + + + +
+ + + +
+ +
+Definition at line 2652 of file ps_emitter.cpp. +
+References nlassert, nlctassert, and type. +
+Referenced by NLNET::CUnifiedNetwork::addNamedCnx(), NLNET::CUnifiedNetwork::addService(), NLNET::CInetAddress::asIPString(), NLNET::CInetAddress::asString(), NLMISC::CConfigFile::CVar::asString(), NLNET::CBufSock::asString(), NL3D::CZoneSymmetrisation::build(), NL3D::CCoarseMeshBuild::buildBitmap(), bytesToHumanReadable(), NLMISC::CEntityIdTranslator::checkEntity(), NLMISC::CLog::CLog(), NLAINIMAT::CMHiCSbase::dbgPrintClassifierPriorityInFile(), NLNET::CUnifiedNetwork::CUnifiedConnection::display(), NLMISC::CHTimer::display(), NLMISC::CHTimer::displayByExecutionPath(), NLMISC::CBitMemStream::displayStream(), NLMISC::CWindowDisplayer::doDisplay(), NLMISC::CMemDisplayer::doDisplay(), NLMISC::CMsgBoxDisplayer::doDisplay(), NLMISC::CFileDisplayer::doDisplay(), NLMISC::CStdDisplayer::doDisplay(), NLMISC::CTaskManager::dump(), dumpOperand(), NL3D::CDriverGL::endProfileVBHardLock(), NLMISC::CVariable< std::string >::execute(), NLGEORGES::CFormElmArray::getArrayNodeName(), NL3D::CFontManager::getCacheInformation(), NLAINIMAT::CMHiCSagent::getDebugString(), NLAINIMAT::CMotivationEnergy::getDebugString(), NLAINIMAT::CClassifierSystem::getDebugString(), NLMISC::CBMSDbgInfo::getEventIdAtBitPos(), NLMISC::CBMSDbgInfo::getEventLegendAtBitPos(), NLMISC::CSystemInfo::getOS(), NLMISC::CBitMemStream::getSerialItem(), NLNET::CUnifiedNetwork::getServiceUnifiedName(), NLNET::IService::getServiceUnifiedName(), NLMISC::CVariable< std::string >::getStat(), NLMISC::CHTimer::CStats::getStats(), NLMISC::CWordsDictionary::init(), NLNET::CUnifiedNetwork::init(), NLNET::internalIPAddressToString(), NL3D::CZoneLighter::light(), NLNET::IService::main(), NLMISC_COMMAND(), NLNET::NLMISC_DYNVARIABLE(), CVPParser::parse(), STRING_MANAGER::prepareStringFile(), NL3D::CDriverGL::profileVBHardAllocation(), NLNET::CNonBlockingBufSock::receivePart(), NLPACS::CGlobalRetriever::refreshLrAround(), NLPACS::CGlobalRetriever::refreshLrAroundNow(), NL3D::CCoarseMeshBuild::remapCoordinates(), NLNET::CUnifiedNetwork::removeNamedCnx(), NLMISC::CTaskManager::run(), secondsToHumanReadable(), NL3D::CPSEmitter::setEmissionType(), NL3D::CDriverGL::setupEXTVertexShader(), NLGEORGES::CFormElm::setValueByName(), NLAINIMAT::CMHiCSagent::targetId2String(), NLMISC::CVector::toString(), NLMISC::CVariable< std::string >::toString(), NLMISC::CVariablePtr< T >::toString(), toString(), NLMISC::CSheetId::toString(), CHashKey::toString(), NLNET::CMessage::toString(), NLNET::CLoginCookie::toString(), toStringEnum(), toStringPtr(), NLNET::uncbDisconnection(), NLNET::uncbServiceIdentification(), NLNET::uNetRegistrationBroadcast(), NLNET::uNetUnregistrationBroadcast(), NLLIGO::CPrimitives::write(), NLLIGO::IPrimitive::write(), NLLIGO::WriteFloat(), and NLLIGO::WriteVector(). +
+
02653 { +02654 nlctassert(NL3D::CPSEmitter::numEmissionType == 5); // If this ct assertion is raised, the content of TEmissionType has changed, so should change this function ! +02655 switch (type) +02656 { +02657 case NL3D::CPSEmitter::regular: return "regular"; +02658 case NL3D::CPSEmitter::onDeath: return "onDeath"; +02659 case NL3D::CPSEmitter::once: return "once"; +02660 case NL3D::CPSEmitter::onBounce: return "onBounce"; +02661 case NL3D::CPSEmitter::externEmit: return "externEmit"; +02662 default: +02663 nlassert(0); +02664 return ""; +02665 break; +02666 } +02667 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
std::string toStringEnum ( const T & val )
+
+ + + + + +
+ + + +
+ +
+Definition at line 171 of file string_common.h. +
+References toString(), and uint32. +
+
00171 { return toString("%u", (uint32)val); } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
std::string toStringPtr ( const T * val )
+
+ + + + + +
+ + + +
+ +
+Definition at line 169 of file string_common.h. +
+References toString(). +
+Referenced by NLNET::CBufSock::asString(). +
+
00169 { return toString("%p", val); } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T, class U>
T type_cast ( U o ) [inline]
+
+ + + + + +
+ + + +
+type_cast<>: this is a function which nlassert() a dynamic_cast in Debug, and just do a static_cast in release. So slow check is made in debug, but only fast cast is made in release. Differs from safe_cast by allowinf NULL objets. +
+Definition at line 520 of file debug.h. +
+
00523 { +00524 return static_cast<T >(o); +00525 } +00526 else +00527 { +00528 return (o==NULL)?NULL:static_cast<T >(o); +00529 } +00530 +00531 } +00532 +00535 #define nlctassert(cond) sizeof(uint[(cond) ? 1 : 0]); +00536 +00537 +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void xmlGenericErrorFuncRead ( void * ctx,
const char * msg,
...
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 129 of file i_xml.cpp. +
+References NLMISC_CONVERT_VARGS, and xmlGenericErrorFuncRead(). +
+Referenced by xmlGenericErrorFuncRead(). +
+
00130 { +00131 // Get the error string +00132 string str; +00133 NLMISC_CONVERT_VARGS (str, msg, NLMISC::MaxCStringSize); +00134 ((CIXml*)ctx)->_ErrorString += str; +00135 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void xmlGenericErrorFuncWrite ( void * ctx,
const char * msg,
...
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 101 of file o_xml.cpp. +
+References NLMISC_CONVERT_VARGS. +
+Referenced by NLMISC::COXml::init(). +
+
00102 { +00103 // Get the error string +00104 string str; +00105 NLMISC_CONVERT_VARGS (str, msg, NLMISC::MaxCStringSize); +00106 ((COXml*)ctx)->_ErrorString += str; +00107 } +

+

+ + + + +
+ + + + + + + + + + +
int xmlOutputCloseCallbackForNeL ( void * context )
+
+ + + + + +
+ + + +
+ +
+Definition at line 662 of file o_xml.cpp. +
+
00663 { +00664 // Get the object +00665 // COXml *object = (COXml*) context; +00666 +00667 // Does nothing +00668 return 1; +00669 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
int xmlOutputWriteCallbackForNeL ( void * context,
const char * buffer,
int len
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 648 of file o_xml.cpp. +
+References NLMISC::COXml::_InternalStream, buffer, len, NLMISC::IStream::serialBuffer(), and uint8. +
+
00649 { +00650 // Get the object +00651 COXml *object = (COXml*) context; +00652 +00653 // Serialise the buffer +00654 object->_InternalStream->serialBuffer ((uint8*)buffer, len); +00655 +00656 // Return the value +00657 return len; +00658 } +

+

Variable Documentation

+ + + + +
+ + +
CLog * NLMISC::AssertLog = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 93 of file debug.cpp. +
+Referenced by NLNET::cbLogFilter(), createDebug(), initDebug2(), NLNET::IService::main(), and NLMISC_COMMAND().
+

+ + + + +
+ + +
string NLMISC::BasePathgetPathContent +
+
+ + + + + +
+ + + +
+ +
+Definition at line 646 of file path.cpp.
+

+ + + + +
+ + +
const uint32 NLMISC::BF_ALWAYS_OPENED = 0x00000001 +
+
+ + + + + +
+ + + +
+Big file management
Author:
Matthieu Besson
+Nevrax France
+
Date:
2002
+ +
+Definition at line 42 of file big_file.h. +
+Referenced by NLMISC::CBigFile::add().
+

+ + + + +
+ + +
const uint32 NLMISC::BF_CACHE_FILE_ON_OPEN = 0x00000002 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 43 of file big_file.h. +
+Referenced by NLMISC::CBigFile::add().
+

+ + + + +
+ + +
TCrashCallback NLMISC::CrashCallback = NULL [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 102 of file debug.cpp. +
+Referenced by getCallStackAndLog(), and setCrashCallback().
+

+ + + + +
+ + +
const uint32 NLMISC::DDS = ((uint32)(uint8)( 'D' ) | ((uint32)(uint8)( 'D' ) << 8) | ((uint32)(uint8)( 'S' ) << 16) | ((uint32)(uint8)( ) << 24 )) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 59 of file bitmap.h. +
+Referenced by NLMISC::EDDSBadHeader::EDDSBadHeader(), NLMISC::CBitmap::load(), and NLMISC::CBitmap::loadSize().
+

+ + + + +
+ + +
CLog * NLMISC::DebugLog = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 92 of file debug.cpp. +
+Referenced by NLNET::cbLogFilter(), createDebug(), NLMISC::CBufFIFO::display(), initDebug2(), NLNET::IService::main(), and NLMISC_COMMAND().
+

+ + + + +
+ + +
bool NLMISC::DebugNeedAssert = false +
+
+ + + + + +
+ + + +
+ +
+Definition at line 85 of file debug.cpp. +
+Referenced by NLMISC::CMsgBoxDisplayer::doDisplay().
+

+ + + + +
+ + +
CMemDisplayer * NLMISC::DefaultMemDisplayer = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 95 of file debug.cpp. +
+Referenced by createDebug(), getCallStackAndLog(), initDebug2(), and NLMISC_COMMAND().
+

+ + + + +
+ + +
CMsgBoxDisplayer * NLMISC::DefaultMsgBoxDisplayer = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 96 of file debug.cpp. +
+Referenced by createDebug(), and initDebug2().
+

+ + + + +
+ + +
const uint32 NLMISC::DXT_ = ((uint32)(uint8)( 'D' ) | ((uint32)(uint8)( 'X' ) << 8) | ((uint32)(uint8)( 'T' ) << 16) | ((uint32)(uint8)( '\0' ) << 24 )) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 60 of file bitmap.h.
+

+ + + + +
+ + +
TEmailFunction NLMISC::EmailFunction = NULL [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 65 of file report.cpp. +
+Referenced by setReportEmailFunction().
+

+ + + + +
+ + +
CLog * NLMISC::ErrorLog = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 89 of file debug.cpp. +
+Referenced by NLNET::cbLogFilter(), createDebug(), initDebug2(), NLNET::IService::main(), and NLMISC_COMMAND().
+

+ + + + +
+ + +
const CClassId NLMISC::EventActivateId(0x7da66b0a, 0x1ef74519) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventActivate::CEventActivate().
+

+ + + + +
+ + +
const CClassId NLMISC::EventCharId(0x552255fe, 0x75a2373f) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventChar::CEventChar().
+

+ + + + +
+ + +
const CClassId NLMISC::EventDestroyWindowId(0x69be73fe, 0x4b07603b) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventDestroyWindow::CEventDestroyWindow().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDAxisMovedId(0x073306, 0x41173626) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDAxisMoved::CGDAxisMoved().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDButtonDownId(0x57141957, 0x3efb143a) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDButtonDown::CGDButtonDown().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDButtonUpId(0x16105e06, 0x302536b2) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDButtonUp::CGDButtonUp().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDMouseMove(0x12142bc4, 0x43c73e74) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDMouseMove::CGDMouseMove().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDPOVChanged(0x362851b9, 0x395c4d61) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDPOVChanged::CGDPOVChanged().
+

+ + + + +
+ + +
const CClassId NLMISC::EventGDSliderMovedId(0x68776586, 0x394a6916) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CGDSliderMoved::CGDSliderMoved().
+

+ + + + +
+ + +
const CClassId NLMISC::EventKeyDownId(0x3c2643da, 0x43f802a1) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventListenerAsync::addToServer(), NLMISC::CEventKeyDown::CEventKeyDown(), NLMISC::CEventListenerAsync::operator()(), and NLMISC::CEventListenerAsync::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventKeyUpId(0x1e62e85, 0x68a35d46) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventListenerAsync::addToServer(), NLMISC::CEventKeyUp::CEventKeyUp(), NLMISC::CEventListenerAsync::operator()(), and NLMISC::CEventListenerAsync::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventMouseDblClkId(0x55a94cb3, 0x3e641517) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventMouseDblClk::CEventMouseDblClk().
+

+ + + + +
+ + +
const CClassId NLMISC::EventMouseDownId(0x35b7878, 0x5d4a0f86) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NL3D::CEvent3dMouseListener::addToServer(), NLMISC::CEventMouseDown::CEventMouseDown(), NL3D::CEvent3dMouseListener::operator()(), and NL3D::CEvent3dMouseListener::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventMouseMoveId(0x3dd12fdb, 0x472f548b) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NL3D::CEvent3dMouseListener::addToServer(), NLMISC::CEventMouseMove::CEventMouseMove(), NL3D::CEvent3dMouseListener::operator()(), and NL3D::CEvent3dMouseListener::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventMouseUpId(0xcce1f7e, 0x7ed344d7) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NL3D::CEvent3dMouseListener::addToServer(), NLMISC::CEventMouseUp::CEventMouseUp(), NL3D::CEvent3dMouseListener::operator()(), and NL3D::CEvent3dMouseListener::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventMouseWheelId(0x73ac4321, 0x4c273150) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NL3D::CEvent3dMouseListener::addToServer(), NLMISC::CEventMouseWheel::CEventMouseWheel(), NL3D::CEvent3dMouseListener::operator()(), and NL3D::CEvent3dMouseListener::removeFromServer().
+

+ + + + +
+ + +
const CClassId NLMISC::EventSetFocusId(0x17650fac, 0x19f85dde) +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLMISC::CEventListenerAsync::addToServer(), NLMISC::CEventSetFocus::CEventSetFocus(), NLMISC::CEventListenerAsync::operator()(), and NLMISC::CEventListenerAsync::removeFromServer().
+

+ + + + +
+ + +
CFileDisplayer* NLMISC::fd = NULL [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 99 of file debug.cpp. +
+Referenced by changeLogDirectory(), createDebug(), and initDebug2().
+

+ + + + +
+ + +
vector<CFileEntry> NLMISC::FileToCheck [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 1547 of file path.cpp. +
+Referenced by NLMISC::CFileEntry::CFileEntry(), NLMISC::CFile::getFileCreationDate(), and NLMISC::CFile::removeFileChangeCallback().
+

+ + + + +
+ + +
bool NLMISC::GlobalAssertCall = false +
+
+ + + + + +
+ + + +
+ +
+Definition at line 87 of file debug.cpp.
+

+ + + + +
+ + +
bool NLMISC::HasMMX = DetectMMX() +
+
+ + + + + +
+ + + +
+ +
+Definition at line 105 of file cpu_info.cpp. +
+Referenced by NLMISC::CCpuInfo___::hasMMX().
+

+ + + + +
+ + +
bool NLMISC::HasSSE = DetectSSE() +
+
+ + + + + +
+ + + +
+ +
+Definition at line 106 of file cpu_info.cpp. +
+Referenced by NLMISC::CCpuInfo___::hasSSE().
+

+ + + + +
+ + +
CLog * NLMISC::InfoLog = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 91 of file debug.cpp. +
+Referenced by NLNET::cbLogFilter(), NLNET::cleanRequest(), createDebug(), NLMISC::CConfigFile::display(), initDebug2(), NLNET::IService::main(), NLMISC_COMMAND(), and NLMISC::CMemDisplayer::write().
+

+ + + + +
+ + +
char NLMISC::JPGBuffer[JPGBufferSize] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 90 of file bitmap.cpp.
+

+ + + + +
+ + +
const uint32 NLMISC::JPGBufferSize = 1000 [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 89 of file bitmap.cpp.
+

+ + + + +
+ + +
NLMISC::IStream* NLMISC::JPGStream = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 88 of file bitmap.cpp.
+

+ + + + +
+ + +
const char* NLMISC::LogTypeToString[][8] [static] +
+
+ + + + + +
+ + + +
+Initial value:
{ + { "", "ERR", "WRN", "INF", "DBG", "STT", "AST", "UKN" }, + { "", "Error", "Warning", "Information", "Debug", "Statistic", "Assert", "Unknown" }, + { "", "A fatal error occurs. The program must quit", "", "", "", "", "A failed assertion occurs", "" }, +} +
+
+Definition at line 71 of file displayer.cpp. +
+Referenced by NLMISC::CMsgBoxDisplayer::doDisplay(), and NLMISC::IDisplayer::logTypeToString().
+

+ + + + +
+ + +
const uint8 NLMISC::MAX_MIPMAP = 16 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 70 of file bitmap.h. +
+Referenced by NLMISC::CBitmap::decompressDXT1(), NLMISC::CBitmap::decompressDXT3(), NLMISC::CBitmap::decompressDXT5(), NLMISC::CBitmap::releaseMipMaps(), and NLMISC::CBitmap::resizeMipMap().
+

+ + + + +
+ + +
const int NLMISC::MaxCStringSize = 1024*2 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 47 of file string_common.h.
+

+ + + + +
+ + +
bool NLMISC::NL3D_BlockMemoryAssertOnPurge = true +
+
+ + + + + +
+ + + +
+See CBlockMemory::Purge. +
+ +
+Definition at line 35 of file block_memory.cpp. +
+Referenced by NLMISC::CBlockMemory< CNode >::purge().
+

+ + + + +
+ + +
const float NLMISC::NL3D_OO255 = 1.0f / 255 [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 41 of file noise_value.cpp. +
+Referenced by NLMISC::CRandomGrid3D::evalBiLinear(), and NLMISC::CRandomGrid3D::evalNearest().
+

+ + + + +
+ + +
CRandomGrid3D NLMISC::NL3D_RandomGrid3D [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 207 of file noise_value.cpp.
+

+ + + + +
+ + +
bool NLMISC::NoAssert = false +
+
+ + + + + +
+ + + +
+ +
+Definition at line 86 of file debug.cpp. +
+Referenced by setAssert().
+

+ + + + +
+ + +
int NLMISC::OptFastFloorBkupCW +
+
+ + + + + +
+ + + +
+ +
+Definition at line 34 of file fast_floor.cpp.
+

+ + + + +
+ + +
int NLMISC::OptFastFloorBkupCW24 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 36 of file fast_floor.cpp.
+

+ + + + +
+ + +
double NLMISC::OptFastFloorMagicConst = pow(2,52) + pow(2,51) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 33 of file fast_floor.cpp.
+

+ + + + +
+ + +
float NLMISC::OptFastFloorMagicConst24 = (float)pow(2,23) +
+
+ + + + + +
+ + + +
+ +
+Definition at line 35 of file fast_floor.cpp.
+

+ + + + +
+ + +
const double NLMISC::Pi = 3.1415926535897932384626433832795 +
+
+ + + + + +
+ + + +
+Pi constant in double format. +
+Definition at line 79 of file common.h. +
+Referenced by NLLIGO::CZoneTemplate::build(), NLLIGO::CZoneEdge::buildMatrix(), NL3D::CZoneLighter::calcSkyContribution(), NL3D::CLodCharacterManager::CLodCharacterManager(), NL3D::CTargetAnimCtrl::CTargetAnimCtrl(), NL3D::CVegetableManager::CVegetableManager(), NL3D::CVegetableQuadrant::CVegetableQuadrant(), degToRad(), NLSOUND::CSourceDSound::getCone(), NL3D::CZoneLighter::getMaxPhi(), H_AUTO_DECL(), NLSOUND::CSound::importForm(), NL3D::CZoneLighter::init(), NL3D::CTessFacePriorityList::init(), NL3D::CEvent3dMouseListener::operator()(), radToDeg(), NLSOUND::CSourceDSound::setCone(), NLSOUND::CSimpleSource::setDirection(), NL3D::CPointLight::setupSpotAngle(), NL3D::CVegetableManager::setupVertexProgramConstants(), NL3D::CMeshVPWindTree::speedCos(), NLMISC::CQuatT< T >::squadrev(), and NL3D::CMiniCol::testMove().
+

+ + + + +
+ + +
const double NLMISC::QuatEpsilon = 0.000001 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 39 of file quat.h. +
+Referenced by NLMISC::CQuatT< T >::exp(), NLMISC::CQuatT< T >::log(), and NLMISC::CQuatT< T >::squadrev().
+

+ + + + +
+ + +
CStdDisplayer* NLMISC::sd = NULL [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 98 of file debug.cpp. +
+Referenced by createDebug(), and initDebug2().
+

+ + + + +
+ + +
const int NLMISC::SEP_SIZE = 1 +
+
+ + + + + +
+ + + +
+ +
+Definition at line 553 of file mem_stream.h. +
+Referenced by NLMISC::CStringStream::serialSeparatedBufferIn(), NLMISC::CMemStream::serialSeparatedBufferIn(), NLMISC::CStringStream::serialSeparatedBufferOut(), and NLMISC::CMemStream::serialSeparatedBufferOut().
+

+ + + + +
+ + +
const char NLMISC::SEPARATOR = ' ' +
+
+ + + + + +
+ + + +
+ +
+Definition at line 552 of file mem_stream.h. +
+Referenced by NLMISC::CStringStream::serial(), NLMISC::CMemStream::serial(), NLMISC::CBitMemStream::serial(), NLMISC::CStringStream::serialSeparatedBufferIn(), NLMISC::CMemStream::serialSeparatedBufferIn(), NLMISC::CStringStream::serialSeparatedBufferOut(), NLMISC::COXml::serialSeparatedBufferOut(), and NLMISC::CMemStream::serialSeparatedBufferOut().
+

+ + + + +
+ + +
const char * NLMISC::SerialTypeToCStr = { "Bool ", "Ui32N", "Ui64N", "Float", "Btfld", "Buffr" } +
+
+ + + + + +
+ + + +
+ +
+Definition at line 45 of file bit_mem_stream.cpp. +
+Referenced by NLMISC::CBMSDbgInfo::getEventLegendAtBitPos().
+

+ + + + +
+ + +
map<TSharedMemId, int> NLMISC::SharedMemIdsToShmids +
+
+ + + + + +
+ + + +
+ +
+Definition at line 48 of file shared_memory.cpp. +
+Referenced by NLMISC::CSharedMemory::createSharedMemory(), and NLMISC::CSharedMemory::destroySharedMemory().
+

+ + + + +
+ + +
const CStringConversion<TKey>::CPair NLMISC::stringTable[] [static] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 37 of file events.cpp.
+

+ + + + +
+ + +
CLog * NLMISC::WarningLog = NULL +
+
+ + + + + +
+ + + +
+ +
+Definition at line 90 of file debug.cpp. +
+Referenced by NLNET::cbLogFilter(), createDebug(), initDebug2(), NLNET::IService::main(), and NLMISC_COMMAND().
+

Generated on Tue Mar 16 13:00:38 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1