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