| NLSOUND::CMusicChannelFader::_CMusicFader | |
| NLNET::_CUniTime | This class provide a independant universal time system |
| binary_function | |
| NLMISC::CBigFile::BNP | |
| NLMISC::CBigFile::BNPFile | |
| NLMISC::CAABBox | An Axis Aligned Bounding Box |
| NLMISC::CAABBoxExt | An Extended Axis Aligned Bouding Box |
| NLMISC::CFairSynchronized< T >::CAccessor | This class give you a thread safe access to the CFairSynchronized Value |
| NLMISC::CUnfairSynchronized< T >::CAccessor | This class give you a thread safe access to the CSynchronized Value |
| NL3D::IDriver::CAdapter | |
| NLSOUND::CAdpcmXAudio2 | CAdpcmXAudio2 |
| NL3D::CAdvance1616Iterator< T, PT > | Class that manage iterator progression with a step of 16:16 in fixed point We assume that T::value_type gives the operator* return type T is the type of the iterator This iterator is READ-ONLY NOTE: this iterator is not intended to serves with STL algo, it doesn't support all the needed features, ++ and * operator are provided as syntaxic sugars |
| NL3D::CAdvance1Iterator< T, PT > | Class that manage iterator progression with a step of 1 We assume that T::value_type gives the operator* return type T is the type of the iterator |
| NLNET::CAlarm | |
| NLNET::CAliveCheck | |
| NL3D::COrderingTable< T >::CAllocator | |
| NL3D::CParticleSystemManager::CAlwaysAnimatedPS | |
| NLMISC::CAngleAxis | An AngleAxis |
| NL3D::CLodCharacterShape::CAnim | A lod Animation |
| NL3D::CAnimatedLightmap | An animated lightmap |
| NL3D::CAnimatedMaterial | An animated material Instance of CMaterialBase NB: formated for 3ds Max :) |
| NL3D::CAnimatedMorph | An animated morph (blend shape) |
| NL3D::CMaterialBase::CAnimatedTexture | |
| NL3D::CAnimatedValueBlendable< T > | A template implementation of IAnimatedValue |
| NL3D::CAnimatedValueBlendable< NLMISC::CQuat > | A QUATERNION implementation of IAnimatedValue |
| NL3D::CAnimatedValueBlendable< NLMISC::CRGBA > | A CRGBA implementation of IAnimatedValue |
| NL3D::CAnimatedValueBlock | This class must contain all the possible AnimatedValue, so the system can work It is used at ITrack evaluation to fill one of these values |
| NL3D::CAnimatedValueNotBlendable< T > | A template implementation of IAnimatedValue not blendable |
| NL3D::CAnimation | This class describes animations for several tracks |
| NL3D::CAnimationOptimizer | Purpose of this class is to optimize for memory and speed a CAnimation |
| NL3D::CAnimationPlaylist | This class |
| NL3D::CAnimationSet | An CAnimationSet is set of CAnimation |
| NL3D::CAnimationSetUser | UAnimationSet implementation |
| NL3D::CLodCharacterShape::CAnimBuild | A lod Animation Build information |
| NL3D::CAnimDetailTrav | The AnimDetail traversal |
| NLMISC::CApplicationContext | This class implement the context interface for the application module That means that this class will really hold the data |
| NLMISC::CArray2D< T > | A simple 2D array |
| NLPACS::CRetrieverInstance::CAStarNodeAccess | The link to another node |
| NLPACS::CRetrieverInstance::CAStarNodeInfo | The information bound to the surfaces nodes |
| NLMISC::CAsyncFileManager | CAsyncFileManager is a class that manage file loading in a seperate thread |
| NL3D::CAsyncFileManager3D | CAsyncFileManager is a class that manage file loading in a seperate thread |
| NLSOUND::CAsyncFileManagerSound | CAsyncFileManagerSound is a class that manage sound file loading in a seperate thread This class mostly depend on the CAsyncFileManager class for serializing async file loas request |
| NL3D::CAsyncTextureBlock | Descriptor of TextureFile Names |
| NL3D::CAsyncTextureManager | Async Loader of textures and Texture Load Balancer |
| NL3D::CMRMBuilder::CAttributeKey | Temp map Attribute/AttributeId |
| NLSOUND::CAudioMixerUser | Implementation of UAudioMixer |
| NLMISC::CStringMapper::CAutoFastMutex | |
| NLMISC::CAutoMutex< TMutex > | Helper class that allow easy usage of mutex to protect a local block of code with an existing mutex |
| NLMISC::CAutoTimer | An automatic measuring timer |
| NLMISC::CAutoTimerInst | Same but display result at end |
| NLSOUND::CBackgroundSound | A background sound static properties |
| NLSOUND::CBackgroundSoundManager | This manager handle the background sound :
- primitive positioned sound (point, path and patatoid supported)
- primitive positioned effect (patatoid only)
- primitive positioned sample bank (patatoid only)
- A set of 32 application definable flag that can be used in background sound to filter the sub sounds of a background sound
|
| NLSOUND::CBackgroundSource | Implemetation class for background source |
| NLPACS::CQuadGrid< T >::CBaseNode | |
| NL3D::CQuadGrid< T >::CBaseNode | A base node (not circular) for the list of selected or unselected node |
| NL3D::CQuadTree< T >::CBaseNode | |
| NLNET::CBaseStruct | Structure used in the second part of the map If you add a client with his service name, the Name is the service name and ServiceNames is empty |
| NL3D::UScene::CBenchResults | For Scene Profiling |
| NL3D::CBezierPatch::CBezierCurve | |
| NL3D::CBezierPatch | A standard bezier patch of float |
| NL3D::CLandscape::CBezierPatchZ | A Bezier patch of One value only |
| NLMISC::CBGRA | Class pixel BGRA, Windows style pixel |
| NLMISC::CBigFile | |
| NL3D::EBadBind::CBindError | |
| NL3D::CPatch::CBindInfo | |
| NL3D::CPatchInfo::CBindInfo | A bind Info on a edge of a patch |
| NLMISC::CBitmap | Class Bitmap |
| NL3D::CCoarseMeshBuild::CBitmapDesc | |
| NLMISC::CBitMemStream | Bit-oriented memory stream |
| NLMISC::CBitSet | A BitSet, to test / set flags quickly |
| NL3D::CBlendShape | |
| NL3D::CTextureDLM::CBlock | A block descriptor |
| NLMISC::CBlockMemory< T, __ctor_dtor__ >::CBlock | Block |
| NLMISC::CBlockMemory< T, __ctor_dtor__ > | Block memory allocation |
| NL3D::CBloomEffect | |
| NLMISC::CBMSDbgInfo | |
| NLMISC::CBigFile::CBNPFileComp | |
| NL3D::CBone | This is a bone, for skeleton animation, with information for result WorldMatrix |
| NL3D::CBoneBase | This is a bone default value |
| NL3D::CSkeletonModel::CBoneCompute | |
| NL3D::CLodCharacterShape::CBoneInfluence | A Bone influence: list of all vertices to influence |
| NL3D::CMeshGeom::CBoneTmp | Just for build process |
| NL3D::CSkeletonModel::CBoneUsage | |
| NL3D::CBorderVertex | The struct for connectivity of zone vertices |
| NLMISC::CBSphere | A bounding Sphere |
| NL3D::CBSPTree< T >::CBSPNode | |
| NLMISC::CBSPNode2v | |
| NL3D::CBSPTree< T > | Class: CBSPTree |
| NLNET::CBufClient | Client class for layer 1 |
| NLSOUND::CBufferAL | OpenAL buffer |
| NLSOUND::CBufferDSound | Buffer for the DSound implementation of the audio driver |
| NLSOUND::CBufferFMod | Buffer for the FMod implementation of the audio driver |
| NLNET::CBufferizedOutPacket | |
| NLSOUND::CBufferXAudio2 | CBufferXAudio2 |
| NLMISC::CBufFIFO | This class is a dynamic size FIFO that contains variable size uint8 buffer |
| NLNET::CBufNetBase | Layer 1 |
| NLNET::CBufServer | Server class for layer 1 |
| NLNET::CBufSock | CBufSock A socket and its sending buffer |
| NL3D::CMeshMultiLod::CMeshMultiLodBuild::CBuildSlot | A slot of mesh for the build |
| NL3D::CCalcLightableShapeRunnable | |
| NLNET::CCallbackClient | Client class for layer 3 |
| NLNET::CCallbackNetBase | Layer 3 |
| NLNET::CCallbackServer | Server class for layer 3 |
| NL3D::CCamera | A Camera node, based on a CTransform node |
| NL3D::CCameraCol | A tool class used to compute differents info for camera collision |
| NL3D::CCameraInfo | A camera descriptor |
| NLSOUND::CCancelLoadWavFile | |
| NL3D::CVisualCollisionMesh::CStaticGrid::CCase | |
| CCeguiRendererNelLibrary | |
| NL3D::CSurfaceLightGrid::CCellCorner | |
| NL3D::CIGSurfaceLightBuild::CCellCorner | A surface cell corner Information |
| NLPACS::CChain | A list of ordered chains of vertices, delimiting 2 surfaces |
| NLPACS::CChainQuad | Quadgrid of list of edge chain |
| NLPACS::CLocalRetriever::CChainReplacement | |
| NLPACS::CLocalRetriever::CTip::CChainTip | A chain tip |
| NL3D::CChannelMixer::CChannel | An animated channel of the CChannelMixer |
| NL3D::CChannelMixer | A channel mixer |
| NLMISC::CSheetId::CChar | Associate sheet id and sheet name |
| NLMISC::CSheetId::CCharComp | |
| NLMISC::CStringMapper::CCharComp | |
| NLNET::CAliveCheck::CCheckAddress | |
| NLLIGO::CPrimitiveClass::CChild | |
| NLMISC::CFixedSizeAllocator::CChunk | |
| NLMISC::CClassId | A unique id to specify Object by a uint64 |
| NLMISC::CClassIdHashMapTraits | Class to be used as a hash traits for a hash_map accessed by CClassId Ex: CHashMap< CClassId, CMyData, CClassIdHashMapTraits> _MyHashMap; |
| NLMISC::CClassRegistry::CClassNode | |
| NLMISC::CClassRegistry | The Class registry where we can instanciate IClassable objects from their names |
| NLNET::CClientReceiveTask | Code of receiving thread for clients |
| NL3D::CTransform::CClipNode | |
| NL3D::CClipTrav | The clip traversal |
| NL3D::CCloud | |
| NL3D::CCloudScape | |
| NL3D::CCloudScapeUser | Implementation of UWaterInstance methods |
| NL3D::CPatchDLMContext::CCluster | A clip cluster, for quadTree of clusters |
| NL3D::CCluster | CCluster |
| NLSOUND::CClusteredSound | This class will manage the clipping/positioning/occlusion of sound placed inside the cluster/portal system |
| NLSOUND::CClusteredSound::CClusterSound | |
| NLSOUND::CClusteredSound::CClusterSoundStatus | This structure contain data about sound status in a cluster |
| NLMISC::CCmdArgs | |
| NL3D::CCoarseMeshBuild | Class used to build the coarse meshes |
| NL3D::CCoarseMeshBuild::CCoarseMeshDesc | Coarse mesh descriptor |
| NL3D::CCoarseMeshManager | Management of coarse meshes |
| NLPACS::CCollisionChain | Temp collision data used during tryMove() |
| NLPACS::CCollisionDesc | Description of the contact of a collision |
| NLPACS::CCollisionFace | |
| NLPACS::CCollisionMeshBuild | The collision intermediate mesh, used to build the real collision meshes |
| NLPACS::CCollisionOT | Odered table element |
| NLPACS::CCollisionOTDynamicInfo | Dynamic collisions descriptor for time odered table |
| NLPACS::CCollisionOTInfo | Collision descriptor for time odered table |
| NLPACS::CCollisionOTStaticInfo | Static collisions descriptor for time odered table |
| NLPACS::CCollisionSurfaceDesc | Description of the contact of a collision against a surface (interior/zones) |
| NLPACS::CCollisionSurfaceTemp | Temp collision data used during resolution of collision within surfaces |
| NLMISC::CCommandRegistry | The command registry is a singleton that hold all available commands |
| NLSOUND::CComplexSound | |
| NLSOUND::CComplexSource | Implemetation class for Complex source |
| NL3D::CComputedString | CComputedString A CComputedString is a structure which permits to render a string in a driver |
| NLMISC::CConcavePolygonsVertexDesc | |
| NLMISC::CConfigFile | CConfigFile class |
| NLLIGO::CPrimitiveClass::CParameter::CConstStringValue | |
| NLSOUND::CContextMatcher< NbJoker, UseRandom, Shift > | |
| NLSOUND::CContextSound | |
| NLSOUND::CContextSoundContainer< NbJoker, UseRandom, Shift > | |
| NLMISC::CContiguousBlockAllocator | One of the simplest scheme of allocation around, but very useful in some situations |
| NLSOUND::CAudioMixerUser::CControledSources | |
| NL3D::CParticleSystem::CCoordSystemInfo | |
| NL3D::CLightInfluenceInterpolator::CCorner | |
| NL3D::CMesh::CCorner | A corner of a face |
| NL3D::CCornerNode | |
| NL3D::CMeshGeom::CCornerPred | |
| NL3D::CMeshGeom::CCornerTmp | Just for build process |
| NLMISC::CCoTask | The coroutine task class encapsulate the coroutines detail and provide an easy to use simple master/slave coroutine model |
| NLMISC::CCpuInfo___ | This helps to know whether cpu has some features such as mmx, sse |
| NLMISC::CCPUTimeStat | Utility class to read cpu time information from /proc/stat and /cpu/pid/stat Allows accurate timing measures for both cpu and process (at least at OS timing accuracy) Call peekMeasures() once in a while (once a second, for instance, to avoid to much load) then call each getCPU |
| NLMISC::IProgressCallback::CCropedValues | |
| NL3D::CPSFloatCurveFunctor::CCtrlPoint | |
| NL3D::CCubeGrid< TCell > | Class used to classify elements in space around a point (good for pointlight raytracing) Elements are copied at insertion, and are duplicated at compilation along the grids |
| NLMISC::CCurrentCoTask | Management of current task in a thread |
| NLMISC::CDbgPtr< T > | |
| NLMISC::CDbgRefCount< T > | |
| NL3D::CDecalIterator | This iterator just return the same value |
| NLLIGO::CPrimitiveClass::CInitParameters::CDefaultValue | |
| NLGEORGES::CType::CDefinition | |
| NL3D::CDeform2d | This perform a 2d deformation effect on the frame buffer, by using the given function and surface |
| NLSOUND::CDeviceDescription | |
| NLPACS::CCollisionSurfaceTemp::CDistanceSurface | |
| NL3D::CDistIterator< TBaseIter > | Iterator that use dist to compute the value |
| NL3D::CDriverD3D | |
| CDriverD3DNelLibrary | |
| NL3D::CDriverGL | |
| CDriverGLNelLibrary | |
| NL3D::CDriverGLStates | Class for optimizing calls to openGL states, by caching old ones |
| NL3D::CDriverUser | UDriver implementation |
| NL3D::CDRU | The driver Utilities class of static |
| NL3D::CDummy2DAngle | |
| NL3D::CDummyCollision | |
| NLNET::CDummyTcpSock | Dummy CTcpSock replacement for replay mode |
| NL3D::CEdge | |
| NLPACS::CExteriorMesh::CEdge | An edge of the edge list |
| NLPACS::CEdgeChainEntry | Temp collision data used during tryMove() |
| NLPACS::CEdgeCollide | Collisions against edge in 2D |
| NLPACS::CEdgeCollideNode | Temp collision data used during tryMove() |
| NLPACS::CCollisionMeshBuild::CEdgeInfo | |
| NLPACS::CCollisionMeshBuild::CEdgeKey | |
| NLPACS::CEdgeQuad | Quadgrid of list of edge chain |
| NLSOUND::CEffectAL | CEffectAL |
| NLSOUND::CEffectXAudio2 | CEffectXAudio2 |
| NLGEORGES::CFormElmArray::CElement | |
| NL3D::CVisualCollisionMesh::CStaticGrid::CEltBuild | |
| NLNET::CEmptyModuleCommBehav< T > | |
| NLNET::CEmptyModuleServiceBehav< T > | |
| NLNET::CEmptySocketBehav< T > | |
| NLMISC::CHeapMemory::CEmptySpace | |
| NLMISC::CEntityIdTranslator::CEntity | Descriptor for an entity in the translator |
| NLMISC::CEntityId | Entity identifier |
| NLMISC::CEntityIdHashMapTraits | Generic hasher for entities |
| NLMISC::CEntityIdTranslator | |
| NLGEORGES::CFormDfn::CEntry | |
| NLMISC::CEnumBitset< EnumType, BitsetType, maxValue, Delimiter, EnumAccessor, SimpleEnumType > | Utility to build 'ored' bit set from a 2 powered enum |
| NLSOUND::IReverbEffect::CEnvironment | Reverb environment |
| NL3D::CZoneSymmetrisation::CError | Error structure |
| NLMISC::CEvalNumExpr | This class performs numerical expression parsing |
| NLMISC::CEvent | CEvent |
| NL3D::CEvent3dMouseListener | CEvent3dMouseListener is a listener that handle a 3d matrix with mouse events |
| NLMISC::CEventActivate | CEventActivate |
| NLMISC::CEventChar | CEventChar |
| NLMISC::CEventDestroyWindow | CEventDestroyWindow |
| NLMISC::CEventDisplayChange | CEventDisplayChange : Called user has changed the desktop resolution |
| NLMISC::CEventEmitterMulti | The composite pattern applied to events emmitters |
| NLMISC::CEventIME | CEventIME |
| NLMISC::CEventKey | CEventKey |
| NLMISC::CEventKeyDown | CEventKeyDown Send when a key is push down |
| NLMISC::CEventKeyUp | CEventKeyUp |
| NLMISC::CEventListenerAsync | CEventListenerAsync |
| NLMISC::CEventMouse | CEventMouse |
| NLMISC::CEventMouseDblClk | CEventMouseDblClk Send when a single mouse button is double clicked |
| NLMISC::CEventMouseDown | CEventMouseDown Send when a single mouse button is pushed down |
| NLMISC::CEventMouseMove | CEventMouseMove Button have the state of the three mouse and SHIFT CTRL and ALT system keys |
| NLMISC::CEventMouseUp | CEventMouseUp Send when a single mouse button is pushed down |
| NLMISC::CEventMouseWheel | CEventMouseWheel Send when the mouse wheel is actioned |
| NLMISC::CEventServer | CEventServer |
| NLMISC::CEventSetFocus | CEventSetFocus |
| NLMISC::CHTimer::CExamStackEntry | For Hierarchical + sorted display |
| NLPACS::CExteriorEdgeEntry | Temp collision data used for exterior mesh collision detection |
| NLPACS::CExteriorMesh | The external mesh of a interior local retriever |
| cf_value | |
| NL3D::CMRMMeshFinal::CFace | |
| NL3D::CMesh::CFace | A Triangle face |
| NL3D::CMiniCol::CFace | |
| NLPACS::CFaceGrid | A selection grid for the interior faces |
| NLPACS::CFaceGrid::CFaceGridBuild | A temporary grid, used to create a static CFaceGrid object |
| NL3D::CMeshGeom::CFaceTmp | Just for build process |
| NLMISC::CFactory< BaseClass, KeyType > | Factory implementation class |
| NLMISC::CFactoryIndirect< BaseFactoryClass, KeyType > | Indirect factory implementation class |
| NLMISC::CFactoryIndirectRegister< IndirectFactoryClass, BaseFactoryClass, SpecializedFactoryClass, KeyType > | |
| NLMISC::CFactoryRegister< FactoryClass, BaseClass, FactoredClass, KeyType > | This class is responsible for creating the factorable object and to register them in the factory instance |
| NL3D::CFadeShadowMapSort | |
| NLMISC::CFairMutex | Kind of "fair" mutex |
| NLMISC::CFairSynchronized< T > | This class is similar to CUnfairSynchronized, but it ensures that the threads are woken-up in the same order as they were put to sleep |
| NL3D::CFarVertexBufferInfo | Info for the current Far VertexBuffer setuped (iether normal or hard) |
| NL3D::CFastHLSModifier | Singleton |
| NLMISC::CFastMem | Functions for Fast Memory manipulation with Pentium-class processors |
| NLMISC::CFastMutex | Fast mutex implementation (not fairly) The mutex ARE NOT recursive (ie don't call enter() several times on the same mutex from the same thread without having called leave()) ; The threads ARE NOT woken-up in the same order as they were put to sleep |
| NLMISC::CFastMutexMP | Fast mutex for multiprocessor implementation (not fairly) |
| NL3D::CFastPtrList< T > | Type Safe version of CFastPtrListBase |
| NL3D::CFastPtrListBase | This class store actually an array of void*, for very fast acces (list is slower because of RAM access) |
| NL3D::CFastPtrListNode | See CFastPtrListBase |
| NL3D::CFClampDot3AddIterator< TBaseIter > | This iterator perform a dot prod with a vector, add an offset. If it is negatif it return MaxInputValue, and take the abs of the result |
| NL3D::CFClampSquareDot3AddIterator< TBaseIter > | This iterator perform a dot prod with a vector, add an offset. If it is negatif it return MaxInputValue, and take the square of the result |
| NL3D::CFDot3AddIterator< TBaseIter > | This iterator perform a dot prod with a vector, add an offset and take the fabs of the result |
| NLMISC::CFile | Utility class for file manipulation |
| NLMISC::CFileContainer | Utility to store a pre-built list of file, bnp and xml_pack Used by CPath to store the default application patch |
| NLMISC::CFileDisplayer | File displayer |
| NLMISC::CFileContainer::CFileEntry | |
| NLMISC::CFileEntry | |
| NLGEORGES::CFileHeader | |
| NLMISC::CAsyncFileManager::CFileLoad | |
| NL3D::CFillStackNode | |
| NLMISC::CFixedSizeAllocator | An allocator that can allocate and deallocate blocks of fixed size in O(1) Blocks are managed by chunks |
| NL3D::CFlareModel | TODO Class description |
| NL3D::CFlareShape | Shape for a flare |
| NL3D::CFontGenerator | Generate bitmap based on a true type font (using freetype2) |
| NL3D::CFontManager | Font manager The font manager manages CMaterial pointers through a list of CSmartPtr |
| NL3D::CForceComputeBoneInfo | |
| NLGEORGES::CForm | This class implement a georges form |
| NL3D::CVectorPacker::CFormat | |
| NLGEORGES::CFormDfn | This class is the defnition for a family of forms |
| NLGEORGES::CFormElm | Base class of form elements |
| NLGEORGES::CFormElmArray | Define an array of elements |
| NLGEORGES::CFormElmAtom | Signed integer element |
| NLGEORGES::CFormElmStruct | Define a structure of elements |
| NLGEORGES::CFormElmStruct::CFormElmStructElm | |
| NLGEORGES::CFormElmVirtualStruct | Define an array of elements |
| NLGEORGES::CFormLoader | Georges form loader implementation |
| CFpuChecker | |
| NLMISC::CFpuChecker | |
| CFpuRestorer | |
| NL3D::CFrustum | A Screen frustum, perspective or orthogonal |
| NL3D::CFSquareDot3AddIterator< TBaseIter > | This iterator perform a dot prod with a vector, add an offset and take the square of the result |
| NL3D::CFXCache | |
| NL3D::CFXInputParams | |
| NL3D::CFXInputValue< T > | |
| NL3D::CFXPassRecord | |
| NL3D::CFXPassRecorder | |
| NLMISC::CGameDeviceDesc | Describe a game device |
| NLMISC::CGameDeviceEvent | An event from a game device (joystick, joypad |
| NLNET::CGatewayL3ClientTransport | Gateway transport using layer 3 client |
| NLNET::CGatewayL3ServerTransport | Gateway transport using layer 3 server |
| NLNET::CGatewayL5Transport | Gateway transport using layer 5 |
| NLNET::CGatewayRoute | Base class for gateway route |
| NLNET::CGatewaySecurity | |
| NLMISC::CGDAxisMoved | An axis has moved |
| NLMISC::CGDButton | A button state has changed |
| NLMISC::CGDButtonDown | A button has been pushed |
| NLMISC::CGDButtonUp | A button has been released |
| NLMISC::CGDMouseMove | A raw mouse move message, expressed in mickeys (relative values) |
| NLMISC::CGDPOVChanged | A point of view control changed |
| NLMISC::CGDSliderMoved | A slider position has changed |
| NL3D::CMRMBuilder::CGeomPred | |
| NL3D::CGlExtensions | The extensions used by NL3D |
| NLPACS::CGlobalRetriever::CGlobalPosition | The global position in the the global retriever |
| NLPACS::CGlobalRetriever | A class that allows to retrieve surface in a large amount of zones (referred as instances |
| NL3D::CPSConstraintMesh::CGlobalTexAnim | Properties of global texture animation |
| NL3D::CPSConstraintMesh::CGlobalTexAnims | Infos for global texture animation |
| NL3D::CParticleSystem::CGlobalVectorValueHandle | |
| NLNET::CGraphUpdate | |
| NLMISC::CGridTraversal | Utility class for incremental grid traversal |
| NLMISC::CBigFile::CHandleFile | |
| NLSOUND::CContextMatcher< NbJoker, UseRandom, Shift >::CHash | |
| CHashKey | |
| NLMISC::CHashKeyMD5 | MD5 Low level routines Largely inspired from the RSA Data Security works |
| CHashMultiMap | |
| NLMISC::CHeapMemory | A Heap manager |
| NL3D::CHeatHaze | This perform a heat haze effect at the horizon of the scene |
| NL3D::CLandscape::CHeightField | |
| NL3D::CZoneLighter::CHeightField | |
| NL3D::CHeightMap | A HeightMap |
| NLMISC::CHistoric< T > | An historic with user defined size |
| NL3D::CFastHLSModifier::CHLSA | |
| NL3D::CHLSColorDelta | |
| NL3D::CHLSColorTexture | A colorisable texture |
| NL3D::CHLSTextureBank | A bank of HLS colorisable textures |
| NL3D::CHLSTextureManager | This is a list of banks of colorisable textures |
| NL3D::CHrcTrav | The hierarchy traversal |
| NLMISC::CHTimer | Hierarchical timing system |
| NLMISC::CI18N | Class for the internationalization |
| NL3D::CIBDrvInfosD3D | |
| NL3D::CDriverD3D::CIBProfile | |
| NL3D::CDriverD3D::CIBState | |
| NLMISC::CIFile | Input File |
| NL3D::CAsyncFileManager3D::CIGLoad | |
| NL3D::CAsyncFileManager3D::CIGLoadUser | |
| NL3D::CIGSurfaceLight | Class owned by CInstanceGroup to get StaticLightSetup for dynamic models |
| NL3D::CIGSurfaceLightBuild | Class used by NL3D::CInstanceLighter to build CIGSurfaceLight with PACS surfaces |
| NLMISC::CImposterLog | Imposter class to wrap all global access to the nel context for backward compatibility Yoyo note: This was a template before, hence with inline |
| NL3D::CIndexBuffer | An index buffer to work with the driver |
| NL3D::CIndexBufferInfo | Info for the last IndexBuffer setuped (iether normal or hard) |
| NL3D::CIndexBufferRead | The index buffer read accessor |
| NL3D::CIndexBufferReadWrite | The index buffer accessor read / write |
| NLNET::CInetAddress | Internet address (IP + port) |
| NLLIGO::CPrimitiveClass::CInitParameters | Init parameters |
| NLMISC::CInputDeviceEventLess | |
| NLMISC::CInputDeviceServer | Base class for an input device server |
| NL3D::CInsertedBitmap | |
| NL3D::CInstanceGroup::CInstance | Instance part |
| NL3D::CSkeletonSpawnScript::CInstance | |
| NLMISC::CInstanceCounterLocalManager | |
| NLMISC::CInstanceCounterManager | |
| NL3D::CInstanceGroup | A CInstanceGroup is a group of mesh instance and so composed by
- A reference to a mesh (refered by the name)
- The transformations to get it to the world
- The parent
|
| NL3D::CLandscapeIGManager::CInstanceGroupElement | |
| NL3D::CInstanceGroupUser | Implementation of the user interface managing instance groups |
| NL3D::CMeshBlockManager::CInstanceInfo | |
| NL3D::CInstanceLighter::CInstanceInfo | |
| NL3D::CInstanceLighter | A class to precompute "StaticSetup" lighting for instances in an InstanceGroup |
| NLPACS::CInt128 | A 128 bits integer |
| NLNET::CInterceptorForwarder< ParentClass > | Interceptor forwarder The trick is that if you build a module interceptor class and then you want to inherit this class in a module definition, then the virtual callbacks are received by the module instead of by your interceptor (because the base module is also an interceptor and it eventualy overides the calls) |
| NL3D::CMesh::CInterface | |
| NL3D::CMesh::CInterfaceLink | For each vertex |
| NL3D::CMesh::CInterfaceVertex | Mesh Interface System for MRM |
| NLPACS::CInteriorBorder | The border of interior surfaces |
| NLPACS::CLocalRetriever::CInteriorFace | The faces used for snapping in interior retrievers |
| NLPACS::CInteriorSurface | The interior surface class |
| NLPACS::CLocalRetriever::CIntersectionMarker | The intersection between an ordered chain and the path |
| NL3D::CIsotropicForceT< T > | Helper class to create isotropic force : they are independant of the basis, and have no position (fluid friction for example) To use this class you should provide to it a functor class that define the () operator with 3 parameters param1 = a const reference to the position of the particle param2 = a reference to the position, that must be updated param3 = a float giving the inverse of the mass param4 = the ellapsed time, in second (has the TAnimationTime type) |
| NLPACS::CLocalRetriever::CIterator | An iterator to go through chains without bothering about ordered chains and those kind of f*cking stuffs |
| NLPACS::CQuadGrid< T >::CIterator | |
| NL3D::CQuadGrid< T >::CIterator | |
| NL3D::CQuadTree< T >::CIterator | |
| NLMISC::CIXml | Input xml stream |
| NL3D::CKey< T > | Interface for a key of a keyframer |
| NL3D::CKeyBezier< T > | Implementation of CKey for Bezier keyframer |
| NL3D::CKeyBezier< NLMISC::CQuat > | Implementation of CKeyBezier for rotation |
| NL3D::CKeyTCB< T > | Implementation of CKey for TCB keyframer |
| NL3D::CKeyTCB< NLMISC::CAngleAxis > | Implementation of CKeyTCB for rotation |
| NLNET::CL3ClientRoute | Layer 3 client transport |
| NLNET::CL3ServerRoute | Specialized route for server transport |
| NLNET::CL5Route | Specialized route for l5 transport |
| NLMISC::CWindowDisplayer::CLabelEntry | |
| NL3D::CLandscape | A landscape |
| NL3D::CLandscapeCollisionGrid | A grid of Tiles Id |
| NL3D::CLandscapeFaceVectorManager | Fast Allocate blocks of faces, according to the size of the block |
| NL3D::CLandscapeGlobals | |
| NL3D::CLandscapeIGManager | This class is used to load and unload IG of landscape |
| NL3D::CLandscapeModel | The model for MOT |
| NL3D::CLandscapeUser | ULandscape Implementation |
| NL3D::CLandscapeVBAllocator | A class to easily allocate vertices for Landscape Far / Tile faces |
| NL3D::CLandscapeVegetableBlock | A block of vegetable IG (one IG per distance type) |
| NL3D::CLandscapeVegetableBlockCreateContext | Information for instanciation of vegetable IG |
| NL3D::CLayeredOrderingTable< T > | The same as an ordering table, but it allows to have several layers for the display |
| NL3D::CLetterColors | |
| NLMISC::CLibrary | |
| NLMISC::CLibraryContext | This class implements the context interface for the a library module |
| NL3D::CLight | Light class to work with driver |
| NL3D::CLightContribution | Light contribution on a model |
| NL3D::CZoneLighter::CLightDesc | |
| NL3D::CInstanceLighter::CLightDesc | |
| NL3D::CLightInfluenceInterpolator | This class is used by CLandscape and IG/Pacs to compute interpolated influence of lights (biLinear-like) on a square |
| NL3D::CMeshBase::CLightInfoMapListV7 | |
| NL3D::CLightingManager | Owned by CLightingTrav |
| NL3D::CMaterial::CLightMap | |
| NL3D::CMeshBase::CLightMapInfoList | |
| NLMISC::CLightMemDisplayer | Same as CMemDisplayer but only display the text (no line, no date, no process |
| NL3D::CLightRunnable | |
| NL3D::CDriverD3D::CLightState | |
| NL3D::CLightTrav | The light traversal |
| NL3D::CLightUser | ULight implementation |
| NLLIGO::CLigoConfig | Ligo config file |
| NLLIGO::CLigoError | Error handling |
| NLMISC::CLine | A simple couple of vertex |
| NL3D::CLinearEquation | |
| NLMISC::CLineColor | A line with 2 colors |
| NLMISC::CLineColorUV | A line with 2 colors and 2 uvs |
| NLMISC::CLineUV | A line with 2 uvs |
| NLPACS::CExteriorMesh::CLink | A neighbor link, on an interior surface |
| NLPACS::CRetrieverInstance::CLink | A neighbor link |
| NLMISC::CListener< Speaker > | |
| NLSOUND::CListenerAL | OpenAL sound listener |
| NLSOUND::CListenerDSound | DirectSound listener |
| NLSOUND::CListenerFMod | FMOD listener |
| NLSOUND::CListenerUser | Implementation of UListener |
| NLSOUND::CListenerXAudio2 | CListenerXAudio2 |
| NLNET::CListenSock | CListenSock: listening socket for servers |
| NLNET::CListenTask | Code of listening thread |
| NL3D::CLoadBalancingGroup | A LoadBalancing Group |
| NL3D::CLoadBalancingTrav | The LoadBalancing traversal |
| NL3D::CZoneManager::CLoadingZone | |
| NL3D::CLoadMeshCancel | |
| NL3D::CLoadTextureCancel | |
| NLSOUND::CAsyncFileManagerSound::CLoadWavFile | |
| NLNET::CLocalGateway | A simple gateway that interconnect module locally For testing purpose and simple case |
| NLPACS::CGlobalRetriever::CLocalPath | |
| NLPACS::CLocalRetriever::CLocalPosition | An estimation of the position of a point on a specified surface |
| NLPACS::CLocalRetriever | A surface retriever, located by its bounding box |
| NL3D::CMRMSewingMesh::CLod | |
| NL3D::CMRMMeshFinal::CLod | |
| NL3D::CSkeletonShape::CLod | This is a lod for skeleton |
| NL3D::CMeshMRMGeom::CLod | A LOD of the MRM |
| NL3D::CMeshMRMSkinnedGeom::CLod | A LOD of the MRM |
| NL3D::CLodCharacterBuilder | A tool class used to build a CLodCharacterShape Use it by first calling setShape(), then add animations to it, and finally get result with getLodShape |
| NL3D::CLodCharacterInstance | An instance of a lodCharacter (stored in CSkeletonModel) |
| NL3D::CLodCharacterManager | A Manager used to display CLodCharacter instances |
| NL3D::CLodCharacterShape | A very Small Shape with anims encoded as Key Meshes |
| NL3D::CLodCharacterShapeBank | A Bank of CLodCharacterShape |
| NL3D::CLodCharacterShapeBuild | A build structure information for building a CLodCharacterShape This is the structure exported from the 3D editor |
| NL3D::CLodCharacterTexture | This describe Texturing information for CLods |
| NL3D::CLodCharacterTmpBitmap | This bitmap is builded in the Instance texturing build process of CLodCharacterManager |
| NL3D::CMeshMRMGeom::CLodInfo | A LOD of the MRM |
| NLMISC::CLog | When display() is called, the logger builds a string and sends it to its attached displayers |
| NLLOGIC::CLogicComparisonBlock | CLogicComparisonBlock |
| NLLOGIC::CLogicCondition | CLogicCondition |
| NLLOGIC::CLogicConditionLogicBlock | CLogicConditionLogicBlock |
| NLLOGIC::CLogicConditionNode | CLogicConditionNode |
| NLLOGIC::CLogicCounter | CLogicCounter |
| NLLOGIC::CLogicEvent | CLogicEvent |
| NLLOGIC::CLogicEventAction | CLogicEventAction |
| NLLOGIC::CLogicEventMessage | CLogicEventMessage |
| NLLOGIC::CLogicState | CLogicState |
| NLLOGIC::CLogicStateMachine | CLogicStateMachine |
| NLLOGIC::CLogicVariable | CLogicVariable |
| NLNET::CLoginClient | |
| NLNET::CLoginCookie | Manage cookie during the authenticate procedure |
| NLNET::CLoginServer | This class is the server part of the Login System |
| NL3D::CLookAtAlign | Vector giving the orientation of look at |
| NLPACS::CGlobalRetriever::CLrLoader | |
| NL3D::CZoneLighter::CLumelCorner | |
| NL3D::CZoneLighter::CLumelCorners | |
| NL3D::CZoneLighter::CLumelDescriptor | |
| NL3D::CLVBSqrDistLUT | |
| STRING_MANAGER::CMakeDiff< ItemType, Context, GetIdentifier, GetHashValue, TestItem > | ItemType must have a property named Identifier that uniquely identify each item |
| NLMISC::CManualSingleton< T > | A variant of the singleton, not fully compliant with the standard design pattern It is more appropriate for object built from a factory but that must be instanciate only once |
| NL3D::CHLSColorTexture::CMask | |
| NL3D::CMaskInfo | |
| NLLIGO::CPrimitiveConfigurations::CMatchGroup | |
| NL3D::CMaterial | A material represent ALL the states relatives to the aspect of a primitive |
| NLLIGO::CMaterial | A ligoscape material |
| NL3D::CMaterialBase | An material Reference for Animated reference |
| NL3D::CMaterialDrvInfosD3D | |
| NL3D::CDriverD3D::CMaterialState | |
| NLMISC::CMatrix | A 4*4 Homogeneous Matrix |
| NL3D::CMatrix3x4 | For fast vector/point multiplication |
| NL3D::CMatrix3x4SSE | Dummy CMatrix3x4SSE for non windows platform |
| NL3D::CMatrix3x4SSEArray | A CMatrix3x4SSE array correctly aligned NB: SSE is no more used (no speed gain, some memory problem), but keep it for possible future usage |
| NL3D::CMeshGeom::CMatrixBlock | A block of RdrPasses, sorted by matrix use |
| NL3D::CMeshGeom::CMatrixBlockRemap | Just for build process |
| NL3D::CDriverUser::CMatrixContext | |
| NL3D::CDriverD3D::CMatrixState | |
| NL3D::CMeshBase::CLightMapInfoList::CMatStage | |
| NL3D::CMeshBase::CMatStageV7 | |
| NLMISC::CFileContainer::CMCFileComp | |
| NLMISC::CFileContainer::CMCFileEntry | |
| NLMISC::CMD5Context | |
| NL3D::CPSConstraintMesh::CMeshDisplayShare::CMDEntry | |
| NLMISC::CMemDisplayer | Display into a string vector |
| NLMISC::CMemStream | Memory stream |
| NLMISC::CMemStreamBuffer | This class implement a copy on write behavior for memory stream buffer |
| NL3D::CMesh | An instanciable mesh |
| NL3D::CMeshBase | A base mesh with just material manipulation |
| NL3D::CMeshBase::CMeshBaseBuild | A mesh material information |
| NL3D::CMeshBaseInstance | An base class for instance of CMesh and CMeshMRM (which derive from CMeshBase) |
| NL3D::CMeshBlender | A tool class used for Alpha Blending of Meshes |
| NL3D::CMeshBlockManager | A class used to render instances sorted by MeshGeom first, then per material, where possible |
| NL3D::CMesh::CMeshBuild | A mesh information |
| NL3D::CMeshMRMGeom::CMeshBuildMRM | A mesh information |
| NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM | A mesh information |
| NL3D::CPSConstraintMesh::CMeshDisplay | Set of rendering pass, and the associated vertex buffer |
| NL3D::CPSConstraintMesh::CMeshDisplayShare | This class manage sharing between several mesh displays |
| NL3D::CMeshGeom | A mesh geometry |
| NL3D::CMeshGeomRenderContext | A render Context used to render MeshGeom |
| NL3D::CCoarseMeshManager::CMeshInfo | |
| NL3D::CMeshInstance | An instance of CMesh |
| NL3D::CVisualCollisionManager::CMeshInstanceCol | |
| NL3D::UVisualCollisionManager::CMeshInstanceColInfo | |
| NL3D::CVisualCollisionManager::CMeshInstanceColInfo | |
| NL3D::CAsyncFileManager3D::CMeshLoad | |
| NL3D::CMeshMorpher | Utility to blend shapes |
| NL3D::CMeshMRM | An instanciable MRM mesh |
| NL3D::CMeshMRMGeom | An MRM mesh geometry, with no materials information |
| NL3D::CMeshMRMInstance | An instance of CMeshMRM |
| NL3D::CMeshMRMSkinned | An instanciable MRM mesh |
| NL3D::CMeshMRMSkinnedGeom | An MRM mesh geometry, with no materials information |
| NL3D::CMeshMRMSkinnedInstance | An instance of CMeshMRMSkinned |
| NL3D::CMeshMultiLod | Mesh with several LOD meshes |
| NL3D::CMeshMultiLod::CMeshMultiLodBuild | Class used to build a multi lod mesh |
| NL3D::CMeshMultiLodInstance | An instance of CMeshMulitLod |
| NL3D::CMeshMultiLod::CMeshSlot | This is a slot of the mesh base list |
| NL3D::CMeshVPPerPixelLight | This vertex program is used to perform perpixel lighting with meshs |
| NL3D::CMeshVPWindTree | VertexProgram for an effect of Wind on Tree meshes |
| NLNET::CMessage | Message memory stream for network |
| NLNET::CMessageRecorder | Message recorder |
| NL3D::CMiniCol | This is a TEMPORARY collision "system" |
| NL3D::CMiniTimer | |
| NL3D::UDriver::CMode | A Graphic Mode descriptor |
| NL3D::CScene::CModelEntry | |
| NL3D::CModeSorter | |
| NLNET::CModuleBase | Basic module implementation |
| NLNET::CModuleFactory< moduleClass > | |
| NLNET::CModuleGateway | Intermediate class must be used as base class for implementing gateway |
| NLNET::CModuleManager | Implementation class for module manager |
| NLNET::CModuleMessageHeaderCodec | Module message header coder/decoder Codec for module message header data |
| NLNET::CModuleProxy | |
| NLNET::CModuleSocket | A base class for socket |
| NLNET::CModuleTask | Base class for module task (aka module coroutine) |
| NLNET::CModuleTracker< ModulePredicate > | A module interceptor that keep of a set of known module that match a given predicate |
| NL3D::CMonitorColorProperties | Monitor color properties |
| NL3D::CMorphBase | An animated morph (blend shape) base |
| NL3D::CMotionBlur | This class help perfoming motion blur on a portion of the screen |
| NLMISC::CMouseSmoother | This smooth position of mouse using cubic splines |
| NLPACS::CMoveCell | Move cell |
| NLPACS::CMoveContainer | A container for movable objects Some constraints: * The move bounding box must be lower than the cell size |
| NLPACS::CMoveElement | Move element linkable in sorted lists |
| NLPACS::CMovePrimitive | Description of movables primitives |
| NLPACS::CMoveSurfaceDesc | Description of the contact of a collision against a chain |
| NL3D::CMRMAttribute | An internal mesh vertex attribute (UV, color, normal |
| NL3D::CMRMBlendShape | An internal mesh representation for MRM |
| NL3D::CMRMMeshFinal::CMRMBlendShapeFinal | |
| NL3D::CMRMBuilder | The class for building MRMs |
| NL3D::CMRMCorner | An internal mesh corner Index representation for MRM |
| NL3D::CMRMEdge | An internal mesh edge Index representation for MRM building |
| NL3D::CMRMEdgeFace | A tuple Edge/Face |
| NL3D::CMRMFace | An internal mesh face representation for MRM |
| NL3D::CMRMFaceBuild | An internal mesh extended face representation for MRM building |
| NL3D::CMRMLevelDetail | Degradation Control for MRM |
| NL3D::CMRMMesh | An internal mesh representation for MRM |
| NL3D::CMRMMeshFinal | An internal MRM mesh representation for MRM, with All lods information |
| NL3D::CMRMMeshGeom | An internal mesh representation for MRM, with geomoprh information |
| NL3D::CMRMParameters | This class is to be used with CMRMBuilder |
| NL3D::CMRMSewingMesh | An internal polygon with LOD information for Interface system |
| NL3D::CMRMVertex | An internal mesh vertex representation for MRM building |
| NL3D::CMRMWedgeGeom | A geomoprh information |
| NLMISC::CMsgBoxDisplayer | Message Box displayer |
| NLMISC::CAsyncFileManager::CMultipleFileLoad | |
| NLSOUND::CMusicBufferVorbis | CMusicBufferVorbis |
| NLSOUND::CMusicChannelFader | CMusicChannelFader |
| NLSOUND::CMusicChannelFMod | CMusicChannelFMod |
| NLSOUND::CMusicChannelXAudio2 | CMusicChannelXAudio2 |
| NLSOUND::CMusicSound | A sound describing a streamable music to play |
| NLSOUND::CMusicSoundManager | A manager that manage multiple CMusicSound that want to play at the same time |
| NLSOUND::CMusicSource | A source that play music |
| NLMISC::CMustConsume< T > | |
| NLGEORGES::CMyEvalNumExpr | |
| NLNET::CNamingClient | Client side of Naming Service |
| NL3D::CNearVertexBufferInfo | Info for the current Far VertexBuffer setuped (iether normal or hard) |
| NLNET::CNelModuleLibrary | Class for pure NeL module library |
| NL3D::CNELU | 3d Engine Utilities |
| NLNET::CNetDisplayer | Net Displayer |
| NLNET::CNetLog | Logger for network transfers |
| NLNET::CNetManager | Layer 4 |
| NLMISC::CNLDebugOverride | |
| NLMISC::CNLInfoOverride | |
| NLMISC::CNLLogOverride | |
| NLMISC::CNLSmartLogOverride | |
| NLMISC::CNLWarningOverride | |
| NLMISC::CFixedSizeAllocator::CNode | |
| NLMISC::CHTimer::CNode | Node in an execution path |
| NL3D::CSkeletonWeight::CNode | An element of the template. A pair of node name / node weight |
| NL3D::COrderingTable< T >::CNode | |
| NL3D::CPlayListManager::CNode | |
| NLPACS::CQuadGrid< T >::CNode | |
| NL3D::CQuadGrid< T >::CNode | An element inserted in the quadGrid |
| NL3D::CQuadTree< T >::CNode | |
| NLMISC::CHTimer::CNodeStat | |
| NL3D::CNoise3d | |
| NLMISC::CNoiseColorGradient | A noisy color generator |
| NLMISC::CNoiseValue | A class which generate noisy value, according to a position |
| NLNET::CNonBlockingBufSock | CNonBlockingBufSock A socket, its send buffer plus a nonblocking receiving system |
| NL3D::CTextureBump::CNormalizationInfo | |
| NL3D::CNormalShaderDesc | |
| NLMISC::CObjectArenaAllocator | An allocator that can allocate/release in O(1) for a finite number of possible blocks size (usually small) |
| NLMISC::CObjectVector< T, EnableObjectBehavior > | The purpose of this class is to copy most (but not all) of stl vector<> features, without some of the speed/memory problems involved:
- size of a vector<T> is 16 bytes typically
|
| NLMISC::CObjectVector< double, true > | |
| NLMISC::CObjectVector< float, true > | |
| NLMISC::CObjectVector< sint16, true > | |
| NLMISC::CObjectVector< sint32, true > | |
| NLMISC::CObjectVector< sint64, true > | |
| NLMISC::CObjectVector< sint8, true > | |
| NLMISC::CObjectVector< uint16, true > | |
| NLMISC::CObjectVector< uint32, true > | |
| NLMISC::CObjectVector< uint64, true > | |
| NLMISC::CObjectVector< uint8, true > | |
| NL3D::COcclusionQueryD3D | |
| NL3D::COcclusionQueryGL | |
| NLMISC::COFile | Output File |
| NLSOUND::CompareSources | |
| NLPACS::CQuadGrid< T >::const_iterator | |
| NL3D::CQuadGrid< T >::const_iterator | |
| NL3D::CQuadTree< T >::const_iterator | |
| NLPACS::COrderedChain | A list of ordered vertices, partially delimiting 2 different surfaces |
| NLPACS::COrderedChain3f | A list of ordered vertices, partially delimiting 2 different surfaces |
| NLPACS::CExteriorMesh::COrderedEdges | A list of edges that are sorted |
| NL3D::COrderFace | |
| NL3D::COrderingTable< T > | |
| NLMISC::COXml | Output xml stream |
| NL3D::CPackedTri | |
| NL3D::CPackedTri16 | |
| NL3D::CPackedVertex | |
| NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer::CPackedVertex | The Final VBuffer |
| NL3D::CMeshMRMSkinnedGeom::CPackedVertexBuffer | The packed vertex buffer |
| NL3D::CPackedWorld | A set of packed zones Allows for world scale collision test with a packed format |
| NL3D::CPackedZone16 | |
| NL3D::CPackedZone32 | |
| NL3D::CPackedZoneBase | A packed zone Compact representation of a zone with fixed tesseletion for raytarcing tests |
| NLNET::CPacsClient | Client side of Pacs Service |
| NLMISC::CStringConversion< DestType, Pred >::CPair | |
| NL3D::CPaletteSkin | Describe index for palette skinning |
| NL3D::CParamCoord | The parametric coordinates of the patch |
| NLLIGO::CPrimitiveClass::CParameter | |
| NL3D::CPSLocated::CParametricInfo | WARNING : private use by forces only |
| NLGEORGES::CForm::CParent | |
| NLGEORGES::CFormDfn::CParent | |
| NL3D::CParticleSystem | This class holds a particle system |
| NL3D::CParticleSystemManager | This class list all the particle systems that have resources allocated at a given time, so that we can remove the resource of those who are too far from the viewer |
| NL3D::CParticleSystemModel | A particle system model : it is built using a CParticleSystemShape |
| NL3D::CParticleSystemProcess | A system particle process; A process is anything that can be called at each update of the system |
| NL3D::CParticleSystemShape | This class helps to instanciate a particle system (the shape contains a particle system prototype stored as a memory stream) Use the createInstance method to insert the system in a scene To load the shape from a file, use a shape stream |
| NL3D::CPatch | A landscape patch |
| NL3D::CPatchBlockIdent | An descriptor of a group of tiles in a patch |
| NL3D::CZone::CPatchConnect | |
| NL3D::CPatchDLMContext | A Dynamic LightMap (DLM) context for a patch |
| NL3D::CPatchDLMContextList | A List of CPatchDLMContext |
| NL3D::CPatchDLMPointLight | A PointLight for Dynamic LightMap (DLM) context for a patch |
| NL3D::CZoneLighter::CPatchForPL | A patch with UnCompressed TileInfluences |
| NL3D::CZoneTgtSmoother::CPatchId | |
| NL3D::CTextureFar::CPatchIdent | |
| NL3D::CPatchIdent | A landscape patch identifier (zone/patch) |
| NL3D::CMiniCol::CPatchIdent | |
| NL3D::CLandscape::CPatchIdentEx | |
| NL3D::CPatchInfo | The struct for building a patch |
| NL3D::CPatchQuadBlock | A group of tiles faces in a patch |
| NL3D::CPatchRdrPass | A render pass for a landscape material (tile or texture far) |
| NL3D::CPatchUVLocator | From a patch and UV coordinate in [0,OrderS], [0,OrderT], retrieve the appropriate coordinate in neighborhood |
| NLMISC::CPath | Utility class for searching files in different paths |
| NLNET::CPendingUser | |
| NL3D::CLodCharacterShapeBuild::CPixelInfo | |
| NL3D::CDriverD3D::CPixelShaderConstantState | |
| NL3D::CDriverD3D::CPixelShaderPtrState | |
| NLMISC::CPlane | Class CPlane |
| NL3D::CPlaneBasis | A basis for plane object, used by particle by face and shockwaves It's a like a 2x3 matrix, (with only the X and Y vector defined) |
| NL3D::CPlaneBasisPair | |
| NL3D::CPSConstraintMesh::CPlaneBasisPair | |
| NL3D::CPlayListManager | This class handles a list of pair PlayList/ChannelMixer RefPointer |
| NL3D::CPlayListManagerUser | UPlayListManager implementation |
| NL3D::CPlayListUser | UPlayList implementation |
| NL3D::CPointLight | Description of a light |
| NL3D::CPointLightNamedArray::CPointLightGroup | LightGroupName mgt |
| NL3D::CPointLightNamedArray::CPointLightGroupV0 | Deprecated serials |
| NL3D::CPointLightInfluence | A pointLight Influence |
| NL3D::CLightingManager::CPointLightInfo | |
| NL3D::CPointLightModel | This model is a dynamic light |
| NL3D::CPointLightNamed | A pointLight with a name, and a default color setup |
| NL3D::CPointLightNamedArray | A class used bi CInstanceGroup and CZone |
| NL3D::CPointLightNamedSort | |
| NL3D::CZoneLighter::CPointLightRT | A PointLight struct to test raytracing |
| NL3D::CInstanceLighter::CPointLightRT | A PointLight struct to test raytracing |
| NLMISC::CPolygon | A polygon, with an unlimited size of vertices |
| NLMISC::CPolygon2D | A 2d convex polygon |
| NLMISC::CPoolMemory< T > | Pool memory allocation |
| NL3D::CPortal | CPortal |
| NLPACS::CPrimitiveWorldImage::CPosition | |
| NL3D::CZoneLighter::CPredPointLightToPoint | For sort() |
| NL3D::CInstanceLighter::CPredPointLightToPoint | For sort() |
| NLLIGO::CPrimAlias | This primitive type is used to handle unique alias across a primitive file |
| NLPACS::CPrimitiveBlock | Block of pacs primitive |
| NLLIGO::CPrimitiveClass | Class of primitive |
| NLLIGO::CPrimitiveConfigurations | Ligo primitive configuration description |
| NLLIGO::CPrimitiveContext | Singleton to manage special loading feature related to unique alias assignment |
| NLPACS::CPrimitiveDesc | PACS primitive description |
| NLLIGO::CPrimitiveEnumerator< Pred > | The primitive enumerator class is used to iterate over primitive node that match a given predicate |
| NL3D::CPrimitiveProfile | A Primitive counter |
| NLLIGO::CPrimitives | This class is a ligo primitives set |
| NLLIGO::CPrimitiveSet< Pred > | Build a primitive set that match the predicate This class makes use of the CPrimitiveEnumerator class to iterate on each valid node and fill the result primitive set |
| NLLIGO::CPrimitiveSetFilter< Pred > | Filter a primitive set against a predicate |
| NLPACS::CPrimitiveWorldImage | Data for the primitive duplicated for each world image it is linked |
| NLLIGO::CPrimNode | |
| NLLIGO::CPrimPath | |
| NLLIGO::CPrimPoint | |
| NLLIGO::CPrimRegion | |
| NLLIGO::CPrimVector | |
| NLLIGO::CPrimZone | |
| NLLIGO::CPropertyColor | |
| NLLIGO::CPropertyString | |
| NLLIGO::CPropertyStringArray | |
| NL3D::CPSAttrib< T > | This class is intended to store an attribute list in a located or in a located bindable such as speed, color and so on |
| NL3D::CPSAttribMaker< T > | This is a base class for any attrib maker |
| NL3D::CPSAttribMakerBase | This is the base for attribute makers |
| NL3D::CPSAttribMakerBinOp< T > | An attribute maker that compute an attribute in a particle system |
| NL3D::CPSAttribMakerMemory< T > | Standard version for attrib maker memory : don't redefine the getMinValue & getMaxValue methods -> meaningful for ordered sets only |
| NL3D::CPSAttribMakerMemory< float > | Specialization for float |
| NL3D::CPSAttribMakerMemory< sint32 > | Specialization for sint32 |
| NL3D::CPSAttribMakerMemory< uint32 > | Specializations for integral types : they have method getMin & getMax We update the min & max value each time a new element is inserted so it is just a minoration or a majoration of the real value |
| NL3D::CPSAttribMakerMemoryBase< T > | This functor |
| NL3D::CPSAttribMakerRGBA< F > | |
| NL3D::CPSAttribMakerT< T, F > | This template generate an attrib maker by defining the methods of the CPSCAttribMaker class |
| NL3D::CPSBaseIterator< TBaseIter > | We define a set of iterator object that can advance with a fixed point step in the source container We have 2 version for each iterator : iterators that advance with a step of 1, and iterators that advance with a fixed point (16 : 16) |
| NL3D::CPSBasisSpinner | This is a spinner : this compute a basis by applying a rotation over the given axis |
| NL3D::CPSBinOp | This struct has an enumeration of various binary operators available with CPSAttribMakerBinOp |
| NL3D::CPSBrownianForce | A Brownian motion |
| NL3D::CPSCentralGravity | Central gravity class. Mass is taken in account here |
| NL3D::CPSCollisionInfo | This structure helps to perform the collision step, by telling which collisionner is the nearest if there are several candidate a distance of -1 indicates that no collisions occured |
| NL3D::CPSColorBinOp | An attribute maker whose output if the result of a binary op on colors |
| NL3D::CPSColorBlender | |
| NL3D::CPSColorBlenderExact | This is a int blender class. It just blend between 2 values. The blending is exact, and thus slow.. |
| NL3D::CPSColoredParticle | This class adds tunable color to a particle. Can be added using public multiple inheritance |
| NL3D::CPSColorGradient | This is a color gradient class NB: a non null gradient must be set before use |
| NL3D::CPSColorMemory | This memorize value by applying some function on the emitter |
| NL3D::CPSConstraintMesh | This class is for mesh that have very simple geometry |
| NL3D::CPSConstraintMeshHelper | Well, we could have put a method template in CPSConstraintMesh, but some compilers want the definition of the methods in the header, and some compilers don't want friend with function template, so we use a static method template of a friend class instead, which gives us the same result :) |
| NL3D::CPSCylindricVortex | Cylindric vortex |
| NL3D::CPSDirection | This class is an interface for object for a particle system that need a direction (forces, emitter |
| NL3D::CPSDirectionnalForce | Force that has the same direction everywhere |
| NL3D::CPSDot | This is just a coloured dot |
| NL3D::CPSEmitter | Base class for all emitters in a particle system |
| NL3D::CPSEmitterConic | The same as a directionnel emitter, but you can also specify the radius for emission |
| NL3D::CPSEmitterDirectionnal | Emit in one direction. This can be the 0, 0, 0 vector |
| NL3D::CPSEmitterInfo | |
| NL3D::CPSEmitterOmni | Emit randomly in all direction |
| NL3D::CPSEmitterRectangle | Emit directionnally in a rectangle (useful to produce snow, drop of water ...) |
| CPSEnterLeave | |
| NL3D::CPSFace | A face particle Unlike FaceLookAt, these particle can have an orientation in space |
| NL3D::CPSFaceHelper | Well, we could have put a method template in CPSFace, but some compilers want the definition of the methods in the header, and some compilers don't want friend with function template, so we use a static method template of a friend class instead, which gives us the same result :) |
| NL3D::CPSFaceLookAt | A FaceLookAt particle These particles can have 2 different size (width and height) when activated |
| NL3D::CPSFaceLookAtHelper | Well, we could have put a method template in CPSFaceLookAt, but some compilers want the definition of the methods in the header, and some compilers don't want friend with function template, so we use a static method template of a friend class instead, which gives us the same result :) |
| NL3D::CPSFanLight | A fan light particle |
| NL3D::CPSFanLightHelper | ==================================================================================== |
| NL3D::CPSFloatBinOp | An attribute maker whose output is the result of a binary op on floats |
| NL3D::CPSFloatBlender | These are some attribute makers for float This is a float blender class |
| NL3D::CPSFloatCurve | |
| NL3D::CPSFloatCurveFunctor | This functor produce float based on a hermite curve NB : must be init before use, or assert occurs |
| NL3D::CPSFloatGradient | This is a float gradient class |
| NL3D::CPSFloatMemory | This memorize float by applying some function on the emitter |
| NL3D::CPSFluidFriction | Fluid friction force |
| NL3D::CPSFluidFrictionFunctor | Fluid friction functor, it is used by the fluid friction class |
| NL3D::CPSForce | All forces in the system derive from this class It has a list with all located on which the force can apply |
| NL3D::CPSForceIntensity | This is a class to set force instensity (acceleration for gravity, k coefficient for springs...) |
| NL3D::CPSForceIntensityHelper | This class defines the newElement, deleteElement, and resize method of a class that derives from CPSForceIntensity And that don't add per paerticle attribute |
| NL3D::CPSGravity | Gravity class. Mass isn't taken in account (true with a uniform gravity model, near earth ) |
| NL3D::CPSHintParticleRotateTheSame | This add a hint to rotated particle : only a few one are rotated, and the other are duplcated |
| NL3D::CPSInputType | This struct only contains an enum that tell what the input of an attribute maker is |
| NL3D::CPSIntBinOp | An attribute maker whose output if the result of a binary op on uint32 |
| NL3D::CPSIntBlender | These are some attribute makers for int |
| NL3D::CPSIntGradient | This is a int gradient class |
| NL3D::CPSIntMemory | This memorize value by applying some function on the emitter |
| NL3D::CPSLight | A group of dynamic light created by a particle system |
| NL3D::CPSLocated | This class is a located : it belongs to a particle system, and it represents any kind of object that has a position in the world |
| NL3D::CPSLocatedBindable | Instance of these class can be bound to a particle system located this include forces, particle, and so on |
| NL3D::CPSMagneticForce | Magnetic field that has the given direction |
| NL3D::CPSMaterial | This contains material of a particle, this doesn't initiliaze anything, this just give the abylity to change the blending mode |
| NL3D::CPSMesh | This class is for mesh handling |
| NL3D::CPSModulatedEmitter | This class helps tuning the emission strenght |
| NL3D::CPSMultiMap< T, U, Pr > | |
| NL3D::CPSMultiTexturedParticle | This class add multitexturing support to particles |
| NL3D::CPSParticle | This is the base class for all particles |
| NL3D::CPSPlaneBasisBinOp | An attribute maker whose output if the result of a binary op on plane basis |
| NL3D::CPSPlaneBasisBlender | These are some attribute makers for plane_basis This is a plane basis class |
| NL3D::CPSPlaneBasisFollowSpeed | This is a 'follow direction' plane basis maker It set the plane basis to have its normal in the same direction than speed of the located The cycle param has no effect o the direction |
| NL3D::CPSPlaneBasisGradient | This is a PlaneBasis gradient class |
| NL3D::CPSPlaneBasisMemory | This memorize value by applying some function based on the emitter |
| NL3D::CPSQuad | This abstract class holds what is needed with quad particles (CPSFaceLookAt, CPSFace) e.g Index and vertex buffer and method to setup them Material, and method to setup them |
| NL3D::CPSRadialEmitter | A radial emitter. The direction gives the normal to the plane of emission |
| NL3D::CPSRibbon | 'Ribbon' particle : a shape is extruded while it follows the particle |
| NL3D::CPSRibbonBase | Base class for ribbons |
| NL3D::CPSRibbonLookAt | A ribbon look at particle |
| NL3D::CPSRotated2DParticle | This class adds tunable 2D rotation to a particle, it can be used by public multiple inheritance |
| NL3D::CPSRotated3DPlaneParticle | This class adds tunable 3D rotation to a PLANE particle, it can be used by public multiple inheritance It must just produce 2 vectors that give the x and y vector of the local basis |
| NL3D::CPSShapeParticle | Base struct for particles that can have a shape (e.g mesh...) |
| NL3D::CPSShockWave | |
| NL3D::CPSShockWaveHelper | Well, we could have put a method template in CPSShockWave, but some compilers want the definition of the methods in the header, and some compilers don't want friend with function template, so we use a static method template of a friend class instead, which gives us the same result :) |
| NL3D::CPSSizedParticle | This class adds tunable size to a particle. Can be added using public multiple inheritance |
| NL3D::CPSSound | This is a goup of sound instances sound instance |
| NL3D::CPSSoundInstanceImpl | This class implement a sound instance (a sound source) |
| NL3D::CPSSoundServImpl | This class implements PS sound server |
| NL3D::CPSSpawnInfo | |
| NL3D::CPSSphericalEmitter | |
| NL3D::CPSSpring | Spring class |
| NL3D::CPSTailDot | These particle are like dot, but a tail is following them |
| NL3D::CPSTailParticle | Base struct for particle that have a tail |
| NL3D::CPSTargetLocatedBindable | This class is a located bindable that can focus on several target Can be inherited by bindable like forces or collision zones |
| NL3D::CPSTextureCategory | |
| NL3D::CPSTexturedParticle | This class adds a texture to a particle |
| NL3D::CPSTexturedParticleNoAnim | This class is an interface for particles that have unanimated textures |
| NL3D::CPSTurbul | |
| NL3D::CPSTurbulForceFunc | Turbulence force functor |
| NL3D::CPSUIntBinOp | An attribute maker whose output if the result of a binary op on uint32 |
| NL3D::CPSUIntBlender | |
| NL3D::CPSUIntGradient | |
| NL3D::CPSUIntMemory | This memorize value by applying some function on the emitter |
| NL3D::CPSUtil | This struct contains utility functions used by the particle system |
| NL3D::CPSValueBlender< T > | This is a Value blender class |
| NL3D::CPSValueBlenderSample< T, n > | This is a Values blender (sampled version, with n sample) class, that operate on value of type T To use this, just derive a class from a specialization of this template , create a ctor, and declare it to the class registry in the ctor, you should call _F.setValue to init the functor object |
| NL3D::CPSValueBlendFunc< T > | This temlate functor blend exactly between 2 value (no samples) To accomplish blending, it use the template function PSValueBlend It is used by CPSValueBlend |
| NL3D::CPSValueBlendFuncBase< T > | Base struct for blending function (exact or sampled) |
| NL3D::CPSValueBlendFuncRGBA | |
| NL3D::CPSValueBlendSampleFunc< T, n > | This temlate functor blend between 2 values by performing n samples (n = template parameter) It may be faster that the CPSValueBlendFunc in some cases |
| NL3D::CPSValueBlendSampleFuncRGBA | |
| NL3D::CPSValueGradient< T > | This is a Values gradient class To use this, just derive a class from a specialization of this template , create a ctor, and declare it to the class registry in the ctor, you should call _F.setValue to init the functor object |
| NL3D::CPSValueGradientFunc< T > | This functor blend between several Value |
| NL3D::CPSValueGradientFuncRGBA | |
| NL3D::CPSVector< T > | |
| NL3D::CPSZone | This class hold any entity that has an effect over located : a sink , a bouncing zone etc This is a kind a specialized force, and it has an attached list of the targets Not sharable accross systems |
| NL3D::CPSZoneCylinder | Caped cylinder |
| NL3D::CPSZoneDisc | Disc |
| NL3D::CPSZonePlane | A plane over which particles bounce It has an interface to move each plane individually |
| NL3D::CPSZoneRectangle | The same as a plane, but with a rectangle |
| NL3D::CPSZoneSphere | A sphere |
| NLMISC::CRefCount::CPtrInfo | |
| NLMISC::CRefCount::CPtrInfoBase | |
| NL3D::CPtrSet< T > | This is a Tool class |
| NL3D::CLightingManager::CQGItLightedModel | An iterator on a model inserted in the ObjectQuadGrid. An id used for eraseStaticLightedModel() |
| NLMISC::CQuad | A simple quad of vertex |
| NLPACS::CQuadBranch | |
| NLMISC::CQuadColor | A quad with 4 colors |
| NLMISC::CQuadColorUV | A quad with 4 colors and 4 uvs |
| NLMISC::CQuadColorUV2 | A quad with 4 colors and 8 uvs |
| NL3D::CQuadEffect | This class allow to create a sequence of small quads that tesselate a poly |
| NLPACS::CQuadGrid< T > | This container is a simple grid, used to quickly find elements |
| NL3D::CQuadGrid< T > | This container is a simple grid, used to quickly find elements |
| NL3D::CQuadGridBase | |
| NL3D::CQuadGridClipCluster | A cluster of object for fast BBox clip |
| NL3D::CQuadGridClipClusterListDist | |
| NL3D::CQuadGridClipClusterQTreeNode | |
| NL3D::CQuadGridClipManager | A quadgrix of QuadGridCluster |
| NLPACS::CQuadLeaf | |
| NL3D::CStaticQuadGrid< T >::CQuadNode | |
| NLPACS::CQuadGrid< T >::CQuadNode | |
| NL3D::CQuadGrid< T >::CQuadNode | A circular list node for the list of node per Quad element |
| NL3D::CQuadTree< T >::CQuadNode | |
| NL3D::CQuadTree< T > | Class: CQuadTree |
| NLMISC::CQuadUV | A quad with 4 uvs |
| NLMISC::CQuat | A float quaternion |
| NLMISC::CQuatD | A double quaternion |
| NL3D::CQuatPack | A packed quaternion |
| NLMISC::CQuatT< T > | A Template quaternion |
| NL3D::CRadiusPair | Radius and its suare in the same struct |
| NL3D::CRadixSort< T > | A class which sort elements T with radix sort algorithm |
| NLMISC::CRandom | A simple, os-independant random generator |
| NLMISC::CRandomGrid3D | A static 3D array of random value + other infos for noise |
| NL3D::CRandomIterator | This special iterator return random values every time it is read It is for private use only, and it has not all the functionnalities of an iterator |
| NLPACS::CRational64 | A Rational of 2 64 bits |
| NL3D::CRawSkinnedNormalCache | The array per lod |
| NL3D::CRawSkinNormalCache | The array per lod |
| NL3D::CRawSkinVertex | A simple Vertex Pos/Normal/Uv |
| NL3D::CRawVertexNormalSkin1 | Vertices influenced by 1 matrix only |
| NL3D::CRawVertexNormalSkin2 | Vertices influenced by 2 matrix only |
| NL3D::CRawVertexNormalSkin3 | Vertices influenced by 3 matrix only |
| NL3D::CRawVertexNormalSkin4 | Vertices influenced by 4 matrix only |
| NL3D::CRawVertexNormalSkinned1 | Vertices influenced by 1 matrix only |
| NL3D::CRawVertexNormalSkinned2 | Vertices influenced by 2 matrix only |
| NL3D::CRawVertexNormalSkinned3 | Vertices influenced by 3 matrix only |
| NL3D::CRawVertexNormalSkinned4 | Vertices influenced by 4 matrix only |
| NL3D::CRayMesh | A tool class |
| NL3D::CShiftedTriangleCache::CRdrPass | |
| NL3D::CMeshGeom::CRdrPass | A block of primitives, sorted by material used |
| NL3D::CPSConstraintMesh::CRdrPass | A rendering pass |
| NL3D::CMeshMRMGeom::CRdrPass | A block of primitives, sorted by material use |
| NL3D::CMeshMRMSkinnedGeom::CRdrPass | A block of primitives, sorted by material use |
| NL3D::CRdrTileId | |
| NLMISC::CRWSynchronized< T >::CReadAccessor | |
| NLMISC::CReaderWriter | This class allows a reader/writer ressource usage policy |
| NLMISC::CRect | This class describe an integer 2d rectangle |
| NLMISC::CRefCount | To use CSmartPtr or CRefPtr, derive from this class |
| NLMISC::CRefPtr< T > | CRefPtr: an handle on a ptr |
| NLNET::CTransportClass::CRegisteredBaseProp | |
| NLNET::CTransportClass::CRegisteredClass | |
| NLNET::CTransportClass::CRegisteredProp< T > | |
| NLNET::CTransportClass::CRegisteredPropCont< T > | |
| NL3D::CDriverD3D::CRenderState | |
| NL3D::CRenderStringBuffer | A Buffer to render batch of computed string |
| NL3D::CDriverD3D::CRenderTargetState | |
| NL3D::CRenderTrav | The Render traversal |
| NL3D::CDriverD3D::CRenderVariable | |
| NL3D::CRenderZBuffer | |
| NLNET::CRequest | |
| NLMISC::CResourcePtr< TPtr, TKey, TResourceFinder > | CResourcePtr: an handle on a ptr |
| NLPACS::CRetrievableSurface | A retrievable surface (inside a local surface retriever) |
| NLPACS::CRetrieverBank | A bank of retrievers, shared by several global retrievers |
| NLPACS::CRetrieverInstance | An instance of a local retriever |
| NL3D::CIGSurfaceLight::CRetrieverLightGrid | |
| NL3D::CIGSurfaceLightBuild::CRetrieverLightGrid | A LocalRetriever Lighting Information |
| NLSOUND::CReverbEffectXAudio2 | CReverbEffectXAudio2 |
| NLMISC::CRGBA | Class pixel RGBA |
| NLMISC::CRGBAF | Class pixel float RGBA |
| NL3D::CShadowPolyReceiver::CRGBAVertex | |
| NL3D::CTessFacePriorityList::CRollingTable | A single rolling table <=> HTable |
| NL3D::CRootModel | The purpose of this model is to do nothing in traverse*() but traverseSons() for Hrc and Clip |
| NLPACS::CRotSurfaceDesc | Description of the contact of a rot collision against a chain |
| NLMISC::CRWSynchronized< T > | This class uses a CReaderWriter object to implement a synchronized object (see mutex.h for standard CSynchronized |
| NL3D::CSegRemanence::CSample | |
| NLMISC::CMouseSmoother::CSample | |
| NLSOUND::CSampleBank | A set of samples |
| NL3D::CDriverD3D::CSamplerState | |
| NL3D::CScene | A CScene, which own a list of Render Traversals, and a render() method |
| NL3D::CSceneUser | TODO Class description |
| NL3D::CScissor | A scissor, used for IDriver rendering |
| NL3D::CPSFaceLookAt::CSecondSize | |
| NL3D::CSegRemanence | A segment (or a more complicated shape) that let a 'trace' when it is moved |
| NL3D::CSegRemanenceShape | Shape for the remanence of a segment (sword stroke |
| NLMISC::CSerialCommand | This class is only used to serialize easily a command for the admin service for example |
| NLNET::CServerBufSock | CServerBufSock A socket, its send buffer plus a nonblocking receiving system for a server connection |
| NLNET::CServerReceiveTask | Code of receiving threads for servers |
| NLNET::CServerTask | Common part of CListenTask and CServerReceiveTask |
| NLNET::CNamingClient::CServiceEntry | |
| NL3D::CShader | Shader resource for the driver |
| NL3D::CShaderDrvInfosD3D | |
| NL3D::CShaderGL | |
| NL3D::CVisualCollisionMesh::CShadowContext | |
| NL3D::CShadowMap | This class encapsulate all Data generated by a Shadow Caster, and read for a Shadow Receiver |
| NL3D::CShadowMapManager | A class to manage the render of shadow map |
| NL3D::CShadowMapProjector | Used to recompute the projection matrix, according to the receiver worldMatrix The problem is material don't support WorldSpace Coordinate Generation, but ObjectSpace ones |
| NL3D::CShadowMapSort | |
| NL3D::CShadowPolyReceiver | A class used to append/remove triangles that will be rendered for ShadowMap Additionally it can be used also for Camera collision for instance |
| NL3D::CShadowSkin | Simple Skinning for shadow map rendering |
| NL3D::CShadowVertex | Vertex for CShadowSkin |
| NL3D::CShapeBank | A CShapeBank handle all the instance of the shapes and the cache management system |
| NL3D::CShapeBankUser | Implementation of the user interface managing shape bank |
| NL3D::CShapeBank::CShapeCache | |
| NL3D::CShapeBank::CShapeInfo | |
| NL3D::CShapeInfo | |
| NL3D::CZoneLighter::CShapeInfo | Struct describing the position of a lightable shape |
| NL3D::CShapeStream | This class is used to serialize a shape |
| NLNET::CLoginClient::CShardEntry | |
| NLMISC::CSharedMemory | Encapsulation of shared memory APIs |
| NLMISC::CSharedMutex | Windows: uses Mutex, the handle can't be shared among processes, but the mutex still can be be shared by passing a common object name to createByName() / createByKey() |
| NLMISC::CSheetId | CSheetId |
| NLMISC::CSheetIdHashMapTraits | Class to be used as a hash traits for a hash_map accessed by CSheetId Ex: hash_map< CSheetId, CMyData, CSheetIdHashMapTraits> _MyHashMap; |
| NL3D::CShiftedTriangleCache | This is a cache of indices which are the copy of CMesh/CMeshMRM indices, but shifted according to a value |
| NLMISC::CAsyncFileManager::CSignal | |
| NLMISC::CSimpleClock | A simple clock to measure ticks |
| NLSOUND::CSimpleSound | A sound buffer and its static properties |
| NLSOUND::CSimpleSource | Implementation of USource |
| NLMISC::CSingleton< T > | Example: |
| NL3D::CSinWave | |
| NL3D::CClipTrav::CSkeletonKey | |
| NL3D::CSkeletonModel | A Skeleton model, instance of CSkeletonShape |
| NL3D::CSkeletonShape | definition of a skeleton |
| NL3D::CSkeletonSpawnScript | For each skeleton, an animation of script can be assigned to spawn and unspawn models, which are sticked to some bones of the skeleton |
| NL3D::CSkeletonWeight | A skeleton template is a set of couple value_name / float |
| NL3D::CSkinSpecularRdrPass | Struct used when SkinGroup is used |
| NL3D::CMesh::CSkinWeight | Skinning: A skin weight for a vertex |
| NL3D::CChannelMixer::CSlot | An animation slot |
| NLMISC::CSmartPtr< T > | Standard SmartPtr class |
| NL3D::CSnappedVector< T, snapPower > | Container that is like a vector, but snapped to (1<<snapPower) byte memory pages |
| NLNET::CSock | CSock: base socket class |
| NL3D::CRadixSort< T >::CSortDigit | |
| NL3D::CSortLight | |
| NL3D::CSortTri | |
| NL3D::CSortVSB | |
| NLSOUND::CSound | A sound base class and its static properties |
| NLSOUND::CSoundAnimation | |
| NLSOUND::CSoundAnimManager | The set of players |
| NLSOUND::CSoundAnimMarker | |
| NLSOUND::CSoundBank | A set of sounds |
| NLSOUND::CSoundContext | |
| NLSOUND::CSoundDriverAL | OpenAL sound driver |
| NLSOUND::CSoundDriverALNelLibrary | |
| NLSOUND::CSoundDriverDSound | |
| NLSOUND::CSoundDriverDSoundNelLibrary | |
| NLSOUND::CSoundDriverFMod | |
| NLSOUND::CSoundDriverFModNelLibrary | |
| NLSOUND::CSoundDriverXAudio2 | CSoundDriverXAudio2 |
| NLSOUND::CSoundDriverXAudio2NelLibrary | |
| NLSOUND::CSoundGroupSerializer | |
| NLSOUND::CSoundPattern | |
| NLSOUND::CSoundSerializer | Pseudo serializer for packed sheet loading/saving |
| NLSOUND::CClusteredSound::CSoundTravContext | This structure is used when we traverse the cluster/portal graph |
| NLSOUND::CSourceAL | OpenAL sound source |
| NLSOUND::CSourceCommon | |
| NLSOUND::CSourceDSound | Keep trace of following states of the DirectSound buffer:
- the buffer is being filled with samples (filling),
- the buffer still contains samples but silence is being written (silencing),
- the buffer contains no samples but only silence (silenced)
|
| NLSOUND::CSourceFMod | DirectSound sound source |
| NLSOUND::CSourceXAudio2 | CSourceXAudio2 |
| NL3D::CParticleSystem::CSpawnVect | |
| NLMISC::CSpeaker< Listener > | |
| NL3D::CSpecCubeMapFunctor | |
| NL3D::CSpinnerFunctor | |
| NL3D::CSSSModelRequest | Used by CSkeletonSpawnScript, to delay model creation |
| NLMISC::CSString | CSString : std::string with more functionalities and case insensitive compare |
| NLNET::CStandardGateway | The standard gateway that interconnect module across process |
| NLSOUND::CStandardReverbEffectAL | CStandardReverbEffectAL |
| NL3D::CStateRecord | |
| NL3D::CStateRecordLight | |
| NL3D::CStateRecordLightEnable | |
| NL3D::CStateRecordMaterial | |
| NL3D::CStateRecordPixelShader | |
| NL3D::CStateRecordPixelShaderConstantB | |
| NL3D::CStateRecordPixelShaderConstantF | |
| NL3D::CStateRecordPixelShaderConstantI | |
| NL3D::CStateRecordRenderState | |
| NL3D::CStateRecordSamplerState | |
| NL3D::CStateRecordTexture | |
| NL3D::CStateRecordTextureStageState | |
| NL3D::CStateRecordTransform | |
| NL3D::CStateRecordVertexShader | |
| NL3D::CStateRecordVertexShaderConstantB | |
| NL3D::CStateRecordVertexShaderConstantF | |
| NL3D::CStateRecordVertexShaderConstantI | |
| NL3D::CVisualCollisionMesh::CStaticGrid | |
| NLMISC::CStaticMap< Key, Typ, Comp > | Implemented with a std::vector Use it not like a map : begin by adding all your values with add()/del()/fromMap() and then call endAdd() that performs a slow sort on the vector and then call find() to find the element you want |
| NL3D::CStaticQuadGrid< T > | This class is builded from a CQuadGrid, and is to be used when:
- sizeof(T) is small (ie a pointer)
- no dynamic insertion are made (builded from a CQuadGrid)
- selection is made with a point, not a BBox
|
| NLMISC::CStaticResourcePtr< TPtr, TKey, TResourceFinder > | CStaticResourcePtr: a CResourcePtr remplacement that doesn't support the resource unload/reload |
| NLMISC::CStaticStringMapper | After endAdd you cannot add strings anymore or it will assert |
| NLMISC::CHTimer::CStats | Some statistics They can be build from a set of nodes |
| NL3D::CCoarseMeshBuild::CStats | Statistics about the build process |
| NLMISC::CHTimer::CStatSorter | A statistics sorter, based on some criterion |
| NLMISC::CstCDbgPtr< T > | |
| NLMISC::CStdDisplayer | Std displayer |
| NLNET::CStdinMonitorSingleton | |
| NLNET::CStdinMonitorThread | |
| NLMISC::CSTLBlockAllocator< T > | This class is a STL block allocator which use CBlockMemory |
| NLMISC::CSTLBlockList< T > | This class is a list<> which use CSTLBlockAllocator |
| NLMISC::CStopWatch | Stopwatch class used for performance measurements and statistics |
| NL3D::CTileLumel::CStreamBit | Stream bit class used to compress the shadow map of the patch |
| NLMISC::CStringConversion< DestType, Pred > | This class allow simple mapping between string and other type (such as integral types or enum) In fact this primarily intended to make a string / enum correspondance Example of use : |
| NLMISC::CStringIdArray | The goal of this class is to associate number and string |
| NLMISC::CStringIdHashMapTraits | |
| NL3D::UTextContext::CStringInfo | The render size of a string |
| NLMISC::CStringMapper | A static class that map string to integer and vice-versa Each different string is tranformed into an unique integer identifier |
| NLMISC::CStringStream | Memory stream that is serialized from/to plain text (human-readable) |
| NL3D::CStripifier | Wrapper to NVidia(tm) Stripifier |
| NL3D::CIGSurfaceLightBuild::CSurface | A surface Lighting Information |
| NLPACS::CSurfaceIdent | Ident of a surface |
| NL3D::CSurfaceInfo | Surface data information structure |
| NL3D::CSurfaceLightGrid | Dynamic objects lighted by IG's Static Lights lookup into this grid |
| NLPACS::CRetrievableSurface::CSurfaceLink | A link from the current surface to a neighbor surface through a chain |
| NLPACS::CCollisionSurfaceTemp::CSurfaceLUTEntry | |
| NLPACS::CSurfaceQuadTree | |
| NLMISC::CSystemInfo | This class provides general system-level information about the local machine |
| NL3D::CZoneTgtSmoother::CTangentId | |
| NL3D::CTargetAnimCtrl | AnimCtrl used to constraint a bone to follow a target, either given by Position or Direction |
| NLMISC::CTaskManager | CTaskManager is a class that manage a list of Task with one Thread |
| NL3D::CTCBTools< CKeyT, T, TMapTimeCKey > | TCB Track tools (for both normal TCB, and quat TCB) |
| CTCBTools< CKeyT, T, TMapTimeCKey > | TCB Track tools (for both normal TCB, and quat TCB) |
| NLNET::CTcpSock | CTcpSock: Reliable socket via TCP |
| NLMISC::CTDS | Thread dependant storage class |
| NL3D::CTempTrackInfo | |
| NL3D::CZone::CTessBaseVertex | |
| NL3D::CTessBlock | A block of 2*2 tiles, for accurate clipping |
| NL3D::CTessFace | A Landscape Triangle |
| NL3D::CTessFacePListNode | A chain link node for PriorityList |
| NL3D::CTessFacePriorityList | This class manage a Priority list of elements, inserted with a "distance" |
| NL3D::CTessFarVertex | |
| NL3D::CTessList< T > | A basic speed list gestion, to add/remove already created Object |
| NL3D::CTessNearVertex | |
| NL3D::CTessNodeList | A basic list node |
| NL3D::CTessVertex | A Landscape Vertex |
| NL3D::CAnimatedMaterial::CTexAnimatedMatValues | |
| NL3D::CMaterialBase::CTexAnimTracks | |
| NL3D::CMaterial::CTexEnv | |
| NL3D::CTextContext | CTextContext |
| NL3D::CTextContextUser | UTextContext implementation |
| NL3D::CAsyncTextureManager::CTextureBase | |
| NL3D::CTextureBlank | This texture does generate nothing, and it is releasable |
| NL3D::CTextureBlend | This is a helper texture that helps to blend between 2 others textures |
| NL3D::CTextureBloom | This texture does generate nothing, and it is releasable |
| NL3D::CTextureBump | This texture is a helper to build a DsDt texture from a height map (provided it is supported by hardware) The height map should be convertible to a RGBA bitmap |
| NL3D::ITexture::CTextureCategory | Category String |
| NL3D::CTextureCross | |
| NL3D::CTextureCube | CTextureCube |
| NL3D::CTextureDebugInfo | |
| NL3D::CTextureDebugKey | |
| NL3D::CTextureDLM | This texture is used by landscape to perform Dynamic LightMap (DLM) |
| NL3D::CTextureDrvInfosD3D | |
| NL3D::CTextureDrvInfosGL | |
| NL3D::CTextureDrvShare | |
| NL3D::CTextureEmboss | This texture is a helper to build a embossed texture from a height map |
| NL3D::CAsyncTextureManager::CTextureEntry | |
| NL3D::CTextureFar | A CTextureFar is a set of texture used to map a whole patch when it is in far Mode |
| NL3D::CTextureFarLevelInfo | |
| NL3D::CTextureFile | CTextureFile |
| NL3D::CTextureFileUser | UTextureFile implementation |
| NL3D::CTextureFont | CTextureFont |
| NL3D::CTextureGrouped | This kind texture is used for grouping several other textures |
| NL3D::CDriverD3D::CTextureIndexState | |
| NL3D::CHLSTextureBank::CTextureInstance | |
| NL3D::CHLSTextureBank::CTextureInstanceHandle | |
| NL3D::CAsyncFileManager3D::CTextureLoad | |
| NL3D::CAsyncTextureManager::CTextureLod | |
| NL3D::CAsyncTextureManager::CTextureLodToSort | |
| NL3D::CTextureMem | CTextureMem |
| NL3D::CTextureMemUser | UTextureMem implementation |
| NL3D::CTextureMultiFile | This kind of texture is like a texture file except that it can encode several texture at once |
| NL3D::CTextureNear | A texture container for lot of little lightmap |
| NL3D::CDriverD3D::CTexturePtrState | |
| NL3D::CDriverD3D::CTextureRef | |
| NL3D::CDriverD3D::CTextureState | |
| NL3D::CTextureUser | UTexture implementation |
| NLMISC::CBigFile::CThreadFileArray | |
| NLMISC::CCPUTimeStat::CTickStat | |
| NL3D::CTile | Tiles |
| NL3D::CTileAddedInfo | |
| NL3D::CTileBank | This class manage tile texture |
| NL3D::CTileBorder | This class is a tile set |
| NL3D::CTileColor | A basic color Element for CPatchTexture |
| NL3D::CTileColorOldPatchVersion6 | Old version of TileColors for correct serialising |
| NL3D::CTileElement | An Element for CPatchTexture |
| NL3D::CTileFace | A tileface |
| NL3D::CTileFarBank::CTileFar | |
| NL3D::CTileFarBank | A bank for the far textures |
| NL3D::CLandscape::CTileInfo | |
| NL3D::CTileLand | Set of tiles for a land |
| NL3D::CTileLightInfluence | For landscape |
| NL3D::CZoneLighter::CTileLightInfUnpack | An UnCompressed TileLightInfluence |
| NL3D::CTileLumel | This class describe an uncompressed lumel for tiles |
| NL3D::CTileMaterial | |
| NL3D::CTileNoise | This class manage tile noise |
| NL3D::CTileNoiseMap | A Noise Map for landscape |
| CTileOfPatch | Struct that helps us to know which tile we've processed |
| NL3D::CTileSet | This class is a tile set |
| NL3D::CTileSetTransition | This class manage a transition tile |
| NL3D::CTileVegetableDesc | A descriptor of vegetables for a tile |
| NL3D::CTileBank::CTileXRef | |
| NLMISC::CTime | This class provide a independant local time system |
| NL3D::CTrackSampledCommon::CTimeBlock | |
| CTimeoutAssertionThread | |
| NLMISC::CHTimer::CTimerStat | |
| NLPACS::CLocalRetriever::CTip | A tip of several chains |
| NL3D::CTmpVertexWeight | |
| NLPACS::CLocalRetriever::CTopology | A topology |
| NL3D::CToVisitEmitter | ======================================================================================= |
| NLSOUND::CTrack | A source selected for playing |
| NL3D::CTrackDefaultBlendable< T > | ITrackDefault implementation for blendable values |
| NL3D::CTrackDefaultBool | |
| NL3D::CTrackDefaultFloat | |
| NL3D::CTrackDefaultInt | |
| NL3D::CTrackDefaultNotBlendable< T > | ITrackDefault implementation for blendable values |
| NL3D::CTrackDefaultQuat | |
| NL3D::CTrackDefaultRGBA | |
| NL3D::CTrackDefaultString | |
| NL3D::CTrackDefaultVector | |
| CTrackKeyFramerBezier< CKeyT, T > | ITrack implementation for Bezier keyframer |
| NL3D::CTrackKeyFramerBezier< CKeyT, T > | ITrack implementation for Bezier keyframer |
| CTrackKeyFramerBezier< CKeyBezierQuat, CQuat > | ITrack implementation for Bezier Quaternion keyframer |
| NL3D::CTrackKeyFramerBezier< CKeyBezierQuat, CQuat > | ITrack implementation for Bezier Quaternion keyframer |
| NL3D::CTrackKeyFramerBezierFloat | |
| NL3D::CTrackKeyFramerBezierInt | |
| NL3D::CTrackKeyFramerBezierQuat | |
| NL3D::CTrackKeyFramerBezierRGBA | |
| NL3D::CTrackKeyFramerBezierVector | |
| NL3D::CTrackKeyFramerConstBlendable< CKeyT, T > | ITrack implementation for Constant keyframer |
| NL3D::CTrackKeyFramerConstBool | |
| NL3D::CTrackKeyFramerConstFloat | |
| NL3D::CTrackKeyFramerConstInt | |
| NL3D::CTrackKeyFramerConstNotBlendable< CKeyT, T > | ITrack implementation for Constant keyframer |
| NL3D::CTrackKeyFramerConstQuat | |
| NL3D::CTrackKeyFramerConstRGBA | |
| NL3D::CTrackKeyFramerConstString | |
| NL3D::CTrackKeyFramerConstVector | |
| NL3D::CTrackKeyFramerLinear< CKeyT, T > | ITrack implementation for linear keyframer |
| NL3D::CTrackKeyFramerLinear< CKeyQuat, CQuat > | Quaternions special implementation for linear keyframer |
| NL3D::CTrackKeyFramerLinear< CKeyRGBA, NLMISC::CRGBA > | ITrack implementation for linear CRGBA keyframer |
| NL3D::CTrackKeyFramerLinearFloat | |
| NL3D::CTrackKeyFramerLinearInt | |
| NL3D::CTrackKeyFramerLinearQuat | |
| NL3D::CTrackKeyFramerLinearRGBA | |
| NL3D::CTrackKeyFramerLinearVector | |
| NL3D::CTrackKeyFramerTCB< CKeyT, T > | ITrack implementation for TCB keyframer |
| CTrackKeyFramerTCB< CKeyT, T > | ITrack implementation for TCB keyframer |
| NL3D::CTrackKeyFramerTCB< CKeyTCBQuat, NLMISC::CAngleAxis > | ITrack implementation for CQuat TCB keyframer |
| CTrackKeyFramerTCB< CKeyTCBQuat, NLMISC::CAngleAxis > | ITrack implementation for CQuat TCB keyframer |
| NL3D::CTrackKeyFramerTCBFloat | |
| NL3D::CTrackKeyFramerTCBInt | |
| NL3D::CTrackKeyFramerTCBQuat | |
| NL3D::CTrackKeyFramerTCBRGBA | |
| NL3D::CTrackKeyFramerTCBVector | |
| NL3D::CTrackSampleCounter | Used to build a CTrackSamplePack from CTrackSampledQuat |
| NL3D::CTrackSampledCommon | Abstract Base class for CTrackSampledQuat and CTrackSampledVector |
| NL3D::CTrackSampledQuat | This track is supposed to be Lighter in memory than CTrackKeyFramerTCBQuat, and also is maybe faster |
| NL3D::CTrackSampledQuatSmallHeader | For minimum CTrackSampledQuat Header Overhead (44 bytes here) |
| NL3D::CTrackSampledVector | This track is supposed to be Lighter in memory than CTrackKeyFramerTCBVector, and also is maybe faster |
| NL3D::CTrackSampleHeader | See CTrackSamplePack |
| NL3D::CTrackSamplePack | See CTrackSampledQuatSmallHeader usage |
| NLMISC::CTraits< T > | Class that gives informations about a type |
| NL3D::CTransform | A basic node which provide an animatable matrix (ITransformable) |
| NL3D::CTransformShape | A transform which "is an instance of"/"point to" a IShape |
| NLLIGO::CTransition | A transition template |
| NLNET::CTransportClass | You have to inherit this class and implement description() and callback() method |
| NLNET::CTransportIdAllocator | Utility class that generate 8bits unique transport id |
| NL3D::CTravCameraScene | A ITravScene traversal, with camera setup (common to CRenderTrav and CClipTrav) |
| NL3D::CTraversal | A Traversal which may be renderable in a CScene |
| NLMISC::CTriangle | A simple triangles of 3 points |
| NL3D::CInstanceLighter::CTriangle | |
| NL3D::CZoneLighter::CTriangle | |
| NLMISC::CTriangleColor | A triangle with 3 colors |
| NLMISC::CTriangleColorUV | A triangle with 3 colors and 3 uvs |
| NL3D::CShadowPolyReceiver::CTriangleId | |
| NL3D::CTrianglePatch | A triangle from a patch identifier |
| NLMISC::CTriangleUV | A triangle with 3 uvs |
| NL3D::CLodCharacterTexture::CTUVQ | The Texture UV Quality info per pixel |
| NLMISC::CTwinMap< TypeA, TypeB > | Bidirectionnal association between values Behaves like a map, but key can be used as value and vice-versa |
| NLGEORGES::CType | This class is a basic type used by atomic form element |
| NLMISC::CUCStringHashMapTraits | |
| NLNET::CUdpSimSock | CUdpSimSock: Unreliable datagram socket via UDP but packet lost, lag simulation |
| NLNET::CUdpSock | CUdpSock: Unreliable datagram socket via UDP |
| NLMISC::CUnfairMutex | Classic mutex implementation (not necessarly fair) Don't assume the mutex are recursive (ie don't call enter() several times on the same mutex from the same thread without having called leave()) ; and don't assume either the threads are woken-up in the same order as they were put to sleep ! |
| NLMISC::CUnfairSynchronized< T > | This class ensure that the Value is accessed by only one thread |
| NLNET::CUnifiedNetwork::CUnifiedConnection | This may contains a CCallbackClient or a TSockId, depending on which type of connection it is |
| NLNET::CUnifiedNetwork | Layer 5 |
| NLMISC::CUnixEventEmitter | TODO Class description |
| CUnsensitiveSStringLessPred | Instead of overriding std::less, please use the following predicate |
| NLMISC::CUnsensitiveStrLessPred | |
| NLMISC::CUpdateThread | |
| NL3D::CParticleSystem::CUserCoordSystemInfo | |
| NL3D::CMaterial::CUserTexMat | |
| NLSOUND::CUserVarSerializer | |
| NLMISC::CUV | 2d UV |
| NL3D::CPatchUVLocator::CUVBasis | |
| NLMISC::CUVW | 3d UV |
| NLMISC::CValueSmoother | |
| NLMISC::CValueSmootherTemplate< T > | A smoother of values |
| NLMISC::CValueSmootherTemplate< bool > | A smoother replacement for boolean |
| NLMISC::CConfigFile::CVar | CVar class |
| NLMISC::CVariable< T > | |
| NLMISC::CVariable< std::string > | |
| NLMISC::CVariablePtr< T > | |
| CVarPath | |
| NL3D::CVBDrvInfosD3D | |
| NL3D::CVBDrvInfosGL | |
| NL3D::CDriverD3D::CVBHardProfile | |
| NL3D::CDriverGL::CVBHardProfile | |
| NL3D::CMeshBlockManager::CVBHeapBlock | |
| NL3D::CPSRibbon::CVBnPB | Struct containing a vertex buffer and the matching primitive block The number of slice is encoded in the upper word of the vb index (the int used to lookup in the map) The number of vertices per slices is encoded in the lower word |
| NL3D::CPSRibbonLookAt::CVBnPB | Struct containing a vertex buffer and a primitive block |
| NL3D::CPSTailDot::CVBnPB | Struct containing a vertex buffer and the matching a primitive block |
| NL3D::CDriverD3D::CVBState | |
| NL3D::CVectInfo | |
| NL3D::CVectNormIterator< TBaseIter > | This special iterator on a vector attributes enables to convert the speed to its norm It is for private use only, and it has not all the functionnalities of an iterator |
| NLMISC::CVector | A 3D vector of float |
| NLMISC::CVector2d | A 2D vector of double |
| NLMISC::CVector2f | A 2D vector of float |
| NL3D::CVector2i | |
| NL3D::CTextureFar::CVector2s | |
| NLPACS::CVector2s | TODO Class description |
| NL3D::CVector3s | |
| NL3D::CLodCharacterShape::CVector3s | A compressed vector information |
| NLMISC::CVectorD | A 3D vector of double |
| NLMISC::CVectorH | Homogeneus vector |
| NL3D::CShadowPolyReceiver::CVectorId | |
| NL3D::CHLSColorTexture::CVectorInt | |
| NL3D::CVectorPacker | |
| NL3D::CVegetable | A vegetable descriptor |
| NL3D::CVegetableBlendLayerModel | A CVegetableBlendLayerModel does not have to be created by user |
| NL3D::CVegetableClipBlock | A block of vegetable instance groups (via sortBlocks) which are clipped in frustum together Internal to VegetableManager |
| NL3D::CVegetableInstanceGroup | A block of vegetable instances |
| NL3D::CVegetableInstanceGroupReserve | Mirror struct of CVegetableInstanceGroup, for reserveIg system in CVegetableManager |
| NL3D::CVegetableInstanceGroup::CVegetableLightedInstance | Reference to an instance which is lighted (precomputed or not) |
| NL3D::CVegetableLightEx | Additional information to light Vegetables |
| NL3D::CVegetableManager | Manager of vegetable |
| NL3D::CVegetableQuadrant | Static Quadrant direction for Vegetable ZSort rdrPass |
| NL3D::CVegetableInstanceGroup::CVegetableRdrPass | |
| NL3D::CVegetableInstanceGroupReserve::CVegetableRdrPass | |
| NL3D::CVegetableShape | A vegetable shape |
| NL3D::CVegetableShapeBuild | A vegetable shape |
| NL3D::CVegetableSortBlock | A block of vegetable instance groups |
| NL3D::CVegetableUV8 | A simple tuple UV in 8 bits, for Dynamic Lightmap encoding in Alpha components of colors |
| NL3D::CVegetableVBAllocator | A VB allocator (landscape like) |
| NLLIGO::CLigoError::CVertex | Vertex error |
| NL3D::CPatchDLMContext::CVertex | |
| NL3D::CVertexArrayRangeARB | |
| NL3D::CVertexArrayRangeATI | Work only if ATIVertexArrayObject is enabled |
| NL3D::CVertexArrayRangeMapObjectATI | TEMP nico : test if better with ATI_map_object_buffer We don't manage a heap there, we just allocate separate objects (can't get a pointer on a portion of the buffer only |
| NL3D::CVertexArrayRangeNVidia | Work only if ARRAY_RANGE_NV is enabled |
| NL3D::CMeshMRMGeom::CVertexBlock | A block of vertices descriptor |
| NL3D::CMeshMRMSkinnedGeom::CVertexBlock | A block of vertices descriptor |
| NL3D::CVertexBuffer | A vertex buffer to work with the driver |
| NL3D::CVertexBufferHardARB | Vb hard using the ARB_vertex_buffer_object extension |
| NL3D::CVertexBufferHardGLATI | Work only if ARRAY_RANGE_NV is enabled |
| NL3D::CVertexBufferHardGLMapObjectATI | Vb hard using the ATI_map_object_buffer extension |
| NL3D::CVertexBufferHardGLNVidia | Work only if ARRAY_RANGE_NV is enabled |
| NL3D::CVertexBufferHeap | A vertex buffer used to group lot of static VB in it |
| NL3D::CVertexBufferInfo | Info for the last VertexBuffer setuped (iether normal or hard) |
| NL3D::CVertexBufferRead | The vertex buffer read accessor |
| NL3D::CVertexBufferReadWrite | The vertex buffer accessor read / write |
| NL3D::CVertexCache | |
| NL3D::CVertexDeclaration | |
| NL3D::CDriverD3D::CVertexDeclState | |
| NL3D::CLodCharacterShape::CVertexInf | |
| NL3D::CLandscapeVBAllocator::CVertexInfo | |
| NL3D::CZoneTgtSmoother::CVertexInfo | |
| NL3D::CVegetableVBAllocator::CVertexInfo | |
| NL3D::CVertexProgamDrvInfosD3D | |
| NL3D::CVertexProgamDrvInfosGL | |
| NL3D::CVertexProgram | This class is a vertex program |
| NL3D::CDriverD3D::CVertexProgramConstantState | |
| NL3D::CDriverD3D::CVertexProgramPtrState | |
| NL3D::CZoneCornerSmoother::CVertexSmoothInfo | |
| NL3D::CVertexStreamManager | A class used to fill a virtual Vertexbuffer, while rendering it, avoiding Stalls during Locks |
| NL3D::CMesh::CVertLink | |
| NL3D::CViewport | CViewport is the description of the viewport used to render with a driver |
| NLMISC::CVirtualRefCount | |
| NLMISC::CVirtualRefPtr< T > | |
| NL3D::CVisualCollisionEntity | An entity created by CVisualCollisionManager |
| NL3D::CVisualCollisionEntityUser | UVisualCollisionEntity implementation |
| NL3D::CVisualCollisionManager | Server to Client collision manager |
| NL3D::CVisualCollisionManagerUser | UVisualCollisionManager implementation |
| NL3D::CVisualCollisionMesh | Collision mesh used for camera collision for instance Additionally used for ShadowMap receiving |
| NL3D::CVisualTileDescNode | Server to Client collision manager |
| NL3D::CVolatileIndexBuffer | |
| NL3D::CVolatileVertexBuffer | |
| CVPInstruction | An instruction in a vertex program with its operands |
| CVPOperand | An operand in a vertex program |
| CVPParser | A vertex program parser |
| CVPSwizzle | Swizzle of an operand in a vertex program |
| NL3D::CSceneUser::CWaitingIG | |
| NL3D::CShapeBank::CWaitingShape | |
| NLMISC::CTaskManager::CWaitingTask | |
| NL3D::CWaterEnvMap | User computed environment map for water reflection Derivers should define the 'render' method to draw the envmap |
| NL3D::CWaterEnvMapUser::CWaterEnvMapInternal | |
| NL3D::CWaterEnvMapRenderFromUScene | Helper class to render faces of a water env cubemap from a UScene at the given position Deriver may redefine the preRender method for scene animation & framebuffer setup |
| NL3D::CWaterEnvMapRenderHelper | Helper class to render faces of a water env cubemap This helps setting the right camera matrix to compute the cubemap faces |
| NL3D::CWaterEnvMapUser | |
| NL3D::CWaterHeightMap | |
| NL3D::CWaterPoolManager::CWaterHeightMapBuild | This struct is used to specify a water pool parameter's |
| NL3D::CWaterModel | A water surface |
| NL3D::CRenderTrav::CWaterModelDump | |
| NL3D::CWaterPoolManager | This class helps managing various waters pools |
| NL3D::CWaterShape | A water shape |
| NL3D::CWaveMakerModel | This model can create wave where it is located. It has no display.. |
| NL3D::CWaveMakerShape | A wave maker. It can generate waves where it is located |
| NL3D::CMRMMeshFinal::CWedge | |
| NLMISC::CWindowDisplayer | This displayer displays on a win32 windows |
| NLMISC::CWordsDictionary | Words dictionary: allows to search for keys and words in <type>_words_<language>.txt Unicode files |
| NLMISC::CRWSynchronized< T >::CWriteAccessor | |
| NLMISC::CXMLPack | The xml pack is a data format to store a great number of XML file in a simple pseudo XML format |
| NL3D::CZoneLighter::CZBuffer | |
| NL3D::CZone | A landscape zone |
| NLLIGO::CZoneBank | |
| NLLIGO::CZoneBankElement | |
| NL3D::CZoneCornerSmoother | A class used to setup CornerSmoothFlag in CPatch |
| NLLIGO::CZoneEdge | A ZoneEdge descriptor |
| NL3D::CMiniCol::CZoneIdent | |
| NL3D::CPackedWorld::CZoneIndexList | |
| NL3D::CPackedWorld::CZoneInfo | |
| NL3D::CZoneInfo | The struct for building a zone |
| NL3D::CZoneSmoother::CZoneInfo | |
| NL3D::CZoneInstance | |
| NL3D::CZoneLighter | |
| NL3D::CZoneLoadingTask | CZoneLoadingTask implement run methode for loading a zone for TaskManager |
| NL3D::CZoneManager | CZoneManager is a class that manage zone loading around of player |
| NLLIGO::CZoneRegion | |
| NL3D::CZoneSearch | CZoneSearch is a class that determine which zone cooresponding to a coordinate and zones are around a position |
| NL3D::CZoneSmoother | A class used to make Bezier patch of zones G1 |
| NL3D::CZoneSymmetrisation | Environnement used to symmetrise zones |
| NLLIGO::CZoneTemplate | Ligo zone template |
| NL3D::CZoneTgtSmoother | A class used to make Vertices coplanar IN or/and across zones |
| NLNET::EAccessDenied | Exception raised when an unauthorized access has been done |
| NLMISC::EAllocationFailure | |
| NL3D::EBadBind | A landscape bind exception |
| NL3D::EBadDisplay | |
| NLMISC::EBadSize | |
| NLMISC::EBadType | |
| NLPACS::EChainQuad | |
| NLMISC::EConfigFile | |
| NLMISC::EDDSBadHeader | |
| NLMISC::EDiskFullError | |
| NL3D::EDru | Exception thrown by CDru::createGlDriver |
| NL3D::EDruOpenglDriverCantCreateDriver | |
| NL3D::EDruOpenglDriverCorrupted | |
| NL3D::EDruOpenglDriverNotFound | |
| NL3D::EDruOpenglDriverOldVersion | |
| NL3D::EDruOpenglDriverUnknownVersion | |
| NLPACS::EEdgeQuad | |
| NLMISC::EFatalError | |
| NLMISC::EFile | File Exception |
| NLMISC::EFileNotFound | |
| NLMISC::EFileNotOpened | |
| NLNET::IModuleGateway::EGatewayAlreadyOpen | The gateway is already open while trying to open it |
| NLNET::IModuleGateway::EGatewayFirewallBreak | Firewall mode is activated but there is already open route ! |
| NLNET::IModuleGateway::EGatewayNotConnected | A gateway is not connected while trying to communicate with |
| NLNET::IModuleGateway::EGatewayNotOpen | The gateway is not open while trying to close it |
| NLNET::IModuleGateway::EGatewayPortInUse | When trying to open the gateway server, the TCP port is already in use |
| NLMISC::EInputDevice | |
| NLNET::IGatewayTransport::EInvalidCommand | Invalid transport command |
| NLMISC::EInvalidDataStream | |
| NLNET::IModule::EInvokeBadReturn | An operation invocation has failed because of a bad return type from servant |
| NLNET::IModule::EInvokeFailed | An operation invocation has failed (mostly because of lost server module) |
| NL3D::CLinearEquation::Element | |
| NLMISC::EMemStream | Exception class for CMemStream |
| NLMISC::EmitterEqualPred | |
| NLNET::IModule::EModuleAlreadyPluggedHere | The module is already plugged in the specified pluging |
| NLNET::EModuleNotPluggedHere | A module use a socket where it is not plugged in |
| NLNET::EModuleNotReachable | The destination module for a message cannot be reached by socket used |
| NLMISC::ENewerStream | |
| NLMISC::ENotInputStream | |
| NLMISC::ENotOutputStream | |
| NLMISC::EOlderStream | |
| NLMISC::EParseError | |
| NLMISC::EPathNotFound | Exception throw when a find is not found in a lookup() call |
| NLMISC::EReadError | |
| NLMISC::EReallocationFailed | Exception raised when a reallocation fails |
| NLMISC::ERegisteredClass | |
| NLMISC::ERegistry | Class Registry Exception |
| NLMISC::ERenameError | |
| NLSOUND::ESampleBankNotFound | ESoundFileNotFound |
| NLMISC::ESeekFailed | |
| NLMISC::ESeekNotSupported | |
| NLNET::EServiceNotFound | Exception raised when a the NS does not find the service looked-up |
| NLNET::ESocket | Network exceptions |
| NLNET::ESocketConnectionClosed | Exception raised when a connection is gracefully closed by peer |
| NLNET::ESocketConnectionFailed | Exception raised when connect() fails |
| NLSOUND::ESoundBankNotFound | ESoundFileNotFound |
| NLSOUND::ESoundDriver | Sound driver exceptions |
| NLSOUND::ESoundDriverCantCreateDriver | ESoundDriverCantCreateDriver |
| NLSOUND::ESoundDriverCorrupted | ESoundDriverCorrupted |
| NLSOUND::ESoundDriverGenBuf | ESoundDriverGenBuf |
| NLSOUND::ESoundDriverGenSrc | ESoundDriverGenBuf |
| NLSOUND::ESoundDriverNoADPCM | ESoundDriverNoADPCM : ESoundDriverNotSupp : ESoundDriver : NLMISC::Exception |
| NLSOUND::ESoundDriverNoBufferStreaming | ESoundDriverNoBufferStreaming : ESoundDriverNotSupp : ESoundDriver : NLMISC::Exception |
| NLSOUND::ESoundDriverNoEnvironmentEffects | ESoundDriverNoEnvironmentEffects : ESoundDriverNotSupp : ESoundDriver : NLMISC::Exception |
| NLSOUND::ESoundDriverNoManualRolloff | ESoundDriverNoManualRolloff : ESoundDriverNotSupp : ESoundDriver : NLMISC::Exception |
| NLSOUND::ESoundDriverNotFound | ESoundDriverNotFound |
| NLSOUND::ESoundDriverNotSupp | ESoundDriverNotSupp |
| NLSOUND::ESoundDriverOldVersion | ESoundDriverOldVersion |
| NLSOUND::ESoundDriverUnknownVersion | ESoundDriverUnknownVersion |
| NLSOUND::ESoundFileNotFound | ESoundFileNotFound |
| NLMISC::EStream | Stream Exception |
| NLMISC::EStreamOverflow | This exception is raised when someone tries to serialize in more than there is |
| NLMISC::EThread | |
| NLNET::IGatewayTransport::ETransportError | Error in the transport |
| NLMISC::ETrapDebug | |
| NLMISC::EUnknownVar | |
| NLMISC::EUnregisteredClass | |
| NLMISC::EWriteError | |
| NLMISC::Exception | Base class for all NeL exception |
| NLMISC::EXmlParsingError | |
| NL3D::GfxMode | A Graphic Mode descriptor |
| __gnu_cxx::hash< std::string > | |
| __gnu_cxx::hash< uint64 > | |
| NL3D::IAddRemoveInstance | Callback to know when an instance group is added / removed from the scene |
| NL3D::IAnimatable | An animatable object |
| NL3D::IAnimatedValue | A value handled by the animation system |
| NL3D::IAnimCtrl | This is a handler for extra Animation behavior on Skeleton Models |
| NL3D::IAsyncLoadCallback | |
| NLSOUND::IBuffer | Sound buffer interface (implemented in sound driver dynamic library) |
| NLMISC::CAsyncFileManager::ICancelCallback | CCancelCallback is an interface that is used in call to CAsyncFileManager::cancelLoad |
| NLMISC::CTaskManager::IChangeTaskPriority | A callback to modify the task priority |
| NLMISC::IClassable | An Object Streamable interface |
| NLPACS::ICollisionCallback | Collision callback interface |
| NLMISC::ICommand | Create a function that can be call in realtime |
| NLMISC::ICommandsHandler | Base class for command handler |
| NLSOUND::IContextSoundContainer | |
| NL3D::ICubeMapFunctor | A cube map functor should return a color from a vector (with each coordinate ranging from [-1..1] |
| ID3DXEffectStateManager | |
| NLMISC::IDbgPtrData | |
| STRING_MANAGER::CMakeDiff< ItemType, Context, GetIdentifier, GetHashValue, TestItem >::IDiffCallback | |
| NLMISC::IDisplayer | Displayer interface |
| NL3D::IDriver | |
| NLMISC::IEventEmitter | CEventEmitter Send events to the event server |
| NLMISC::IEventListener | Interface for event listener |
| NLMISC::IFactoryIndirectRegister< BaseFactoryClass > | Interface class for object registered in the indirect factory |
| NLMISC::IFactoryRegister< BaseClass > | Interface class for object registered in the factory |
| NLMISC::IGameDevice | This abstract a joystick or gamepad |
| NLNET::IGatewayTransport | Interface class for gateway transport |
| NL3D::IIBDrvInfos | Index buffer driver informations |
| NL3D::IIGAddBegin | Callback to know when an instance group begin to be added |
| NLMISC::IInputDevice | Base class that wrap to a device |
| NLMISC::IInputDeviceEvent | An event from an input device |
| NLMISC::IInputDeviceManager | Interface for objects that give low level access to devices (mouse, keyboard, joypads and joysticks) |
| NLNET::IInterceptorRegistrar | |
| NLMISC::IKeyboardDevice | Gives access to low level keyboard parameters
- 'Shift' messages are replaced by RShift and LShift msg
|
| NL3D::ILandscapePolyDrawingCallback | |
| NLMISC::IListener | |
| NLSOUND::IListener | Sound listener interface (implemented in sound driver dynamic library) |
| NLMISC::CI18N::ILoadProxy | Proxy interface for loading string file |
| NL3D::ILogicInfo | An interface for UScene to retrieve client information for a specified UTransform ( see UTransfrom::setLogicInfo() ) |
| NL3D::IMaterialDrvInfos | Driver info for the material |
| NL3D::IMeshGeom | Interface for MeshGeom |
| NL3D::IMeshVertexProgram | Interface to a CMeshGeom/CMeshMRMGeom Special VertexProgram Effect |
| NLSOUND::CAudioMixerUser::IMixerEvent | Intergace for registering object in the mixer eventlist |
| NLSOUND::CAudioMixerUser::IMixerUpdate | Interface for registering object in the mixer update |
| NLNET::IModule | This is the interface for the a module |
| NLNET::IModuleFactory | Interface for module factory |
| NLNET::IModuleGateway | Interface for gateway |
| NLNET::IModuleInterceptable | This interface contains some module methods that can be intercepted |
| NLNET::IModuleManager | This is the interface for the module manager |
| NLNET::IModuleProxy | This interface is implemented by the system and it give convenient access to distant module information like module name or id, it also provide a helper to send module message without knowing the gateway |
| NLNET::IModuleSocket | |
| NLNET::IModuleTrackerCb | Callback class used by the CModuleTracker class below and to be implemented if you want callback when tracked module are up/down |
| NLMISC::IMouseDevice | An interface to a low level mouse device |
| NLSOUND::IMusicBuffer | IMusicBuffer |
| NLSOUND::IMusicChannel | IMusicChannel |
| NLMISC::INelContext | Interface definition for nel context |
| NLMISC::INelLibrary | Interface class for 'pure Nel' library module |
| NLSOUND::CSoundPattern::IntervalIterator | |
| NL3D::IOcclusionQuery | Interface to an occlusion query object |
| NL3D::CDeform2d::IPerturbUV | Interface to compute the u,v perturbations at a given point (x and and y range from 0 to 1) |
| NLLIGO::IPrimitive | |
| NLMISC::IProcess | Process base interface, must be implemented for all OS |
| NLMISC::IProgressCallback | Progress callback interface |
| NLLIGO::IProperty | |
| NL3D::CParticleSystemModel::IPSModelObserver | Interface for object that observe this model. They will be notified when it becomes invalid |
| NL3D::IPSMover | In this file, we define interfaces to interact more precisely with located in a particle system It allows to manipulate individual elements of a located For example, it allows you to move a collision plane after its creation, or to move a particular particle that you've instancied yourself |
| NLPACS::IQuadNode | |
| NLSOUND::IReverbEffect | IReverbEffect |
| NLMISC::IRunnable | Thread callback interface |
| NLMISC::IRunnablePos | A class derived from IRunnable to get a position |
| NLNET::IService | Base class for all network services |
| NLNET::IServiceUpdatable | Interface class for object that need an update call during each service loop |
| NL3D::IShaderDrvInfos | Interface for shader driver infos |
| NL3D::IShape | The basic interface for shapes |
| NLSOUND::ISoundDriver | Abstract sound driver (implemented in sound driver dynamic library) |
| NLSOUND::ISource | Sound source interface (implemented in sound driver dynamic library) |
| NLMISC::ISpeaker | |
| NLNET::IStdinMonitorSingleton | |
| NLMISC::IStream | A IO stream interface |
| NLMISC::IStreamable | An Object Streamable interface |
| NLSOUND::ISoundDriver::IStringMapperProvider | The interface must be implemented and provided to the driver in order to have a coherent string mapping |
| NLSOUND::CSoundPattern::Iterator | |
| NL3D::ITexture | Interface for textures |
| NL3D::ITextureDrvInfos | |
| NLMISC::IThread | Thread base interface, must be implemented for all OS |
| NL3D::ITrack | The track store an animation of an animated value |
| NL3D::ITrackDefault | ITrack interface for default tracks |
| NL3D::ITrackKeyFramer< CKeyT > | ITrack interface for keyframer |
| ITrackKeyFramer | |
| NL3D::ITransformable | Something which can be transformed in 3D space / animated |
| NL3D::ITransformName | Callback class used at instancegroup loading |
| NLMISC::IVariable | |
| NLMISC::IVariableChangedCallback | This class can provide a callback called when the value of a variable has been changed |
| NL3D::IVBDrvInfos | |
| NL3D::IVertexArrayRange | Interface to a Big block of AGP memory either throurgh NVVertexArrayRange or ATIVertexObject |
| NL3D::IVertexBufferHardGL | Common interface for both NVidia and ATI extenstion |
| NL3D::IVertexProgramDrvInfos | |
| NL3D::IWaterEnvMapRender | |
| NL3D::IWaterSurfaceAddedCallback | |
| IXAudio2VoiceCallback | |
| less | |
| Logger | |
| CEGUI::NeLRenderer::NeLInputDriver | |
| CEGUI::NeLLogger | NeLLogger |
| CEGUI::NeLRenderer | Class to interface with the NeL rendering engine |
| CEGUI::NeLResourceProvider | |
| CEGUI::NeLTexture | |
| NL3D_CComputeTileFar | |
| NL3D_CExpandLightmap | |
| NLSOUND::CSoundPattern::PatternIterator | |
| CEGUI::NeLRenderer::QuadInfo | |
| Renderer | |
| ResourceProvider | |
| NLNET::SAdminViewRow | |
| NL3D::SCloudScapeSetup | |
| NL3D::CCloudScape::SCloudSchedulerAccel | |
| NL3D::CCloudScape::SCloudSchedulerEntry | |
| NL3D::SCloudTexture3D | |
| NL3D::SCloudTextureClamp | |
| NLMISC::semun | |
| SHA1Context | |
| NL3D::CLetterColors::SLetterColor | |
| NL3D::CTextureFont::SLetterInfo | |
| NL3D::CTextureFont::SLetterKey | |
| NLLIGO::SPiece | |
| NL3D::CCloudScape::SSortedCloudEntry | |
| NL3D::CZoneManager::SZoneManagerWork | A Work is a removed zone or a loaded zone |
| NLLIGO::CZoneRegion::SZoneUnit | |
| NLLIGO::CZoneRegion::SZoneUnit2 | |
| T | |
| NLSOUND::IBuffer::TADPCMState | |
| NL3D::CParticleSystemManager::TAlwaysAnimatedModelHandle | |
| NLSOUND::UAudioMixer::TBackgroundFilterFades | Structure that contain the background filter fadein and fade out delay These are configuration data |
| NLSOUND::UAudioMixer::TBackgroundFlags | Structure that contain the background flags |
| NLSOUND::CBackgroundSoundManager::TBanksData | Storage for a samples banks zone |
| NLNET::TBinBuffer | An utility struct to serial binary buffer |
| NLMISC::TBMSDbgInfoData | |
| NLMISC::TBMSSerialInfo | |
| NLNET::TBroadcastModuleMessage< PtrContainer > | Utility class to do broadcast with a container of proxy pointer |
| NLNET::TCallbackItem | Callback items. See CMsgSocket::update() for an explanation on how the callbacks are called |
| STRING_MANAGER::TClause | |
| NLMISC::TCommandHandler< T > | |
| NLMISC::TCommandHandlerClassInfo | Struct to host data for all the commands of an object class |
| NLMISC::TCommandHandlerInfo | Struct to host data for one object command |
| NLMISC::TCommandParams | |
| NLNET::CUnifiedNetwork::CUnifiedConnection::TConnection | The connection structure |
| NLMISC::TContainedEnum< EnumType, BitsetType > | |
| NLMISC::TCoTaskData | |
| NLNET::TSecurityData::TCtorParam | |
| NLNET::IGatewayTransport::TCtorParam | Constructor param needed by the factory (see nel/misc/factory.h) |
| NLNET::CGatewaySecurity::TCtorParam | |
| NLSOUND::CSourceDSound::TCursors | The play and write cursors |
| NLMISC::CLog::TDisplayInfo | |
| Texture | |
| NLSOUND::CSampleBank::TFilteredBank | |
| NLSOUND::TFindId | |
| NLNET::CMessage::TFormat | |
| NL3D::CTextureGrouped::TFourUV | Group of 4 uvs |
| NLSOUND::TFrameStereo< T > | |
| NLSOUND::CBackgroundSoundManager::TFxZone | Storage for a fx zone |
| STRING_MANAGER::TGetHashValue< ItemType > | |
| STRING_MANAGER::TGetIdentifier< ItemType > | |
| STRING_MANAGER::TGetWorksheetHashValue | |
| STRING_MANAGER::TGetWorksheetIdentifier | |
| NLSOUND::THashPtr< Pointer > | Hasher functor for hashed container with pointer key |
| NLMISC::TInstanceCounterData | Data for instance counting |
| NLNET::CStandardGateway::TKnownModuleInfo | A structure to hold foreign proxy information |
| NLNET::TLocalMessage | Message waiting next update for local dispatching |
| NLSOUND::CSourceDSound::TLockedBufferInfo | A locked buffer info |
| NLPACS::CRetrievableSurface::TLoop | A list of chain WARNING: a loop is a list of index in the surface link list _Chains !! This is not directly the ChainId ChainId is _Chains[loop[i]].Chain !!! |
| NLMISC::CMemStreamBuffer::TMemStreamBuffer | |
| NLNET::TMessageRecord | |
| NL3D::CParticleSystemManager::TModelHandle | |
| NLNET::TModuleClassPred | A canonical module predicate that test a module for a specified module class name |
| NLNET::TModuleDescCodec | Sub message for module description |
| NLNET::TModuleDistanceChangeMsg | Message for module distance update |
| NLNET::CModuleManager::TModuleLibraryInfo | |
| NLNET::TModuleOperationMsg | Message for module operation |
| NLNET::TModuleRemMsg | Message for module removing |
| NLNET::TModuleSecurityChangeMsg | Message for module security update |
| NLNET::TModuleTask< T > | Template module task |
| NLMISC::TMutableContainer< BaseContainer > | Container wrapper that allow read/write access to element stored in a const container |
| NLNET::CUnifiedNetwork::TNameMappedConnection | A map of service ids, referred by a service name |
| NLNET::TParsedCommandLine | Structure for pre-parsed command line parameters Support in memory representation of parameter line like : 'tag1(x=1 y=2 z=3) tag2=6 tag3(a=abc b=xyz tag4)' |
| NLNET::CGatewayRoute::TPendingEvent | |
| STRING_MANAGER::TPhrase | |
| STRING_MANAGER::TPhraseDiffContext | |
| NLLIGO::TPrimitiveClassAndNamePredicate | Predicate for primitive enumerator |
| NLLIGO::TPrimitiveClassPredicate | Default predicate for primitive enumerator |
| NLLIGO::TPrimitiveNamePredicate | Predicate for primitive enumerator |
| NLLIGO::TPrimitivePropertyPredicate | Predicate for primitive enumerator |
| NLMISC::CI18N::TReadContext | Structure to hold contextual info during read of preprocessed file |
| NLSOUND::CAudioMixerUser::TSampleBankHeader | |
| NLNET::TSecurityData | Base class for module identification data Application writer should derive from this class to create there own security information |
| NLNET::TSecurityDataDesc | |
| NLNET::TServiceId | This class encapsulate the serviceId format |
| NLNET::TServiceId8 | This class encapsulate the 8 bits service id |
| NLMISC::CSheetId::TSheetId | Sheet id |
| NLMISC::TSimpleEnum< EnumType, BitsetType > | |
| NLSOUND::CBackgroundSoundManager::TSoundData | Storage for all a sound in a layer |
| NLSOUND::CBackgroundSound::TSoundInfo | Associtation clas for storage of sound / filter |
| NLSOUND::CBackgroundSoundManager::TSoundStatus | |
| STRING_MANAGER::TStringDiffContext | |
| STRING_MANAGER::TStringInfo | |
| NLSOUND::CBackgroundSource::TSubSource | Sub source info |
| STRING_MANAGER::TTestItem< ItemType > | |
| STRING_MANAGER::TTestWorksheetItem | |
| NL3D::TTexDrvInfoPtrMap | |
| NLNET::TTransportDesc | |
| NLNET::TUnifiedCallbackItem | Callback items. See CMsgSocket::update() for an explanation on how the callbacks are called |
| NLNET::TUnknownSecurityData | |
| STRING_MANAGER::TWordsDiffContext | |
| STRING_MANAGER::TWorksheet | |
| NLMISC::CXMLPack::TXMLFileInfo | A descriptor for one file inside the pack |
| NLMISC::CXMLPack::TXMLPackInfo | A descriptor for the content of an xml pack file |
| NL3D::U3dMouseListener | 3d mouse listener |
| NL3D::UAnimation | Give manual access to the animation functions |
| NL3D::UAnimationSet | An animation Set is a set of animation, loaded from file |
| NLSOUND::UAudioMixer | Game interface for audio |
| NL3D::UBone | Base interface for manipulating Bones |
| NL3D::UCamera | Game interface for manipulating Camera |
| NL3D::UCloudScape | |
| NLPACS::UCollisionDesc | Description of the contact of a collision |
| ucstring | |
| NL3D::UDriver | Game Interface for window Driver, first object to create |
| NLGEORGES::UForm | This class provide an interface to access Georges form |
| NLGEORGES::UFormDfn | Georges DFN ifle interface |
| NLGEORGES::UFormElm | |
| NLGEORGES::UFormLoader | Georges form loader interface |
| NLPACS::UGlobalPosition | The global position in the global retriever |
| NLPACS::UGlobalRetriever | A class that allows to retrieve surface in a large amount of zones (referred as instances |
| NL3D::UInstance | Game interface for manipulating Objects, animations etc |
| NL3D::UInstanceGroup | Game interface for managing group instance |
| NL3D::UInstanceMaterial | Base interface for manipulating Material retrieved from UInstance |
| NL3D::UTrackKeyframer::UKeyBezierFloat | |
| NL3D::UTrackKeyframer::UKeyLinearFloat | |
| NL3D::UTrackKeyframer::UKeyTCBFloat | |
| NL3D::ULandscape | Game Interface for manipulate Landscape |
| NL3D::ULandscapeTileCallback | Callback to know when a tile of a landscape has been added/removed |
| NL3D::ULetterColors | |
| NL3D::ULight | ULight implementation |
| NLSOUND::UListener | Game interface for listener control |
| NLPACS::ULocalPosition | An estimation of the position of a point on a specified surface |
| NL3D::UMaterial | Game Interface for Material |
| NLPACS::UMoveContainer | A container for movable objects Some constraints: * The move bounding box must be lower than the cell size |
| NLPACS::UMovePrimitive | Description of movables primitives |
| unary_function | |
| NL3D::UParticleSystemInstance | Interface to manipulate a particle system |
| NL3D::UParticleSystemSound | This init the sound for particle systems |
| NL3D::UPlayList | A playlist/channelmixer, from which you setup your mix of animations (blend, skeleton template weight |
| NL3D::UPlayListManager | A manager of playlist |
| NL3D::UPointLight | Game interface for manipulating Dynamic Lights |
| NLPACS::UPrimitiveBlock | Block of pacs primitives, user interface |
| NL3D::UPSSoundInstance | This is an interface between the particle system and a sound instance |
| NL3D::UPSSoundServer | This class is an interface which allow the particle system to create a sound |
| NL3D::URenderStringBuffer | Abstract Class to render string into a temporary buffer |
| NLPACS::URetrieverBank | TODO Class description |
| NL3D::UScene | Game Interface for Scene |
| NL3D::UShape | Game interface for managing shape |
| NL3D::UShapeBank | Game interface for managing shape bank |
| NL3D::USkeleton | Game interface for manipulating Skeleton |
| NLSOUND::USource | Game interface for sound sources (stereo or 3D sound instances) |
| NL3D::UTextContext | A game interface to render string |
| NL3D::UTexture | Game interface for manipulating Basic texture |
| NL3D::UTextureFile | Game interface for manipulating texture File |
| NL3D::UTextureMem | Game interface for manipulating texture RAW |
| NL3D::UTrack | A track is a fonction that interpolate a value over the time |
| NL3D::UTrackKeyframer | This is a keyframer track interface |
| NL3D::UTransform | Base interface for manipulating Movable Objects in the scene: camera, lights, instances etc |
| NL3D::UTransformable | Base interface for manipulating Movable Objects: camera, bones, lights, instances etc |
| NLPACS::UTriggerInfo | Description of the contact of a collision |
| NLGEORGES::UType | Georges type interface |
| NL3D::UVisualCollisionEntity | Interface to visual collision entity |
| NL3D::UVisualCollisionManager | Interface to visual collision manager |
| NL3D::UVisualCollisionMesh | Proxy to a Collision Mesh possibly stored in a UShape |
| NL3D::UWaterEnvMap | An environment map that can be rendered by user |
| NL3D::UWaterHeightMap | Interface to water height maps |
| NL3D::UWaterHeightMapManager | Interface to the water height map manager |
| NL3D::UWaterInstance | Helps to get infos about a water model You can get this interface by using a dynamic_cast on a UInstance that is a water instance |
| NLMISC::CStaticMap< Key, Typ, Comp >::value_compare | |
| yy_buffer_state | |
| YYSTYPE | |
